Struct TetherAgentOptionsBuilder

Source

pub struct TetherAgentOptionsBuilder { /* private fields */ }

Implementations§

Source §

impl TetherAgentOptionsBuilder

Source

pub fn new(role: &str) -> Self

Initialise Tether Options struct with default options; call other methods to customise. Call build() to get the actual TetherAgent instance (and connect automatically, by default)

Examples found in repository ?

examples/custom_options.rs (line 8)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

More examples

Hide additional examples

examples/publish.rs (line 22)

14fn main() {
15    println!("Rust Tether Agent publish example");
16
17    let mut builder = Builder::from_env(Env::default().default_filter_or("info"));
18    builder.init();
19
20    debug!("Debugging is enabled; could be verbose");
21
22    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
23        .build()
24        .expect("failed to connect Tether");
25    let (role, id, _) = tether_agent.description();
26    info!("Created agent OK: {}, {}", role, id);
27
28    let empty_message_output = PlugOptionsBuilder::create_output("nothing")
29        .build(&mut tether_agent)
30        .expect("failed to create output");
31    let boolean_message_output = PlugOptionsBuilder::create_output("one")
32        .build(&mut tether_agent)
33        .expect("failed to create output");
34    let custom_output = PlugOptionsBuilder::create_output("two")
35        .topic(Some("custom/custom/two"))
36        .build(&mut tether_agent)
37        .expect("failed to create output");
38    let grouped_output_1 = PlugOptionsBuilder::create_output("one")
39        .id(Some("groupMessages"))
40        .build(&mut tether_agent)
41        .expect("failed to create output");
42    let grouped_output_2 = PlugOptionsBuilder::create_output("two")
43        .id(Some("groupMessages"))
44        .build(&mut tether_agent)
45        .expect("failed to create output");
46
47    for i in 1..=10 {
48        info!("#{i}: Sending empty message...");
49        tether_agent.publish(&empty_message_output, None).unwrap();
50
51        let bool = i % 2 == 0;
52        info!("#{i}: Sending boolean message...");
53        tether_agent
54            .publish(&boolean_message_output, Some(&[bool.into()]))
55            .unwrap();
56
57        info!("#{i}: Sending custom struct message...");
58        let custom_message = CustomStruct {
59            id: i,
60            name: "hello".into(),
61        };
62        tether_agent
63            .encode_and_publish(&custom_output, custom_message)
64            .unwrap();
65
66        info!("#{i}: Sending grouped messages...");
67        tether_agent.publish(&grouped_output_1, None).unwrap();
68        tether_agent.publish(&grouped_output_2, None).unwrap();
69
70        thread::sleep(Duration::from_millis(1000))
71    }
72}

examples/subscribe.rs (line 27)

17fn main() {
18    println!("Rust Tether Agent subscribe example");
19
20    let mut builder = Builder::from_env(Env::default().default_filter_or("debug"));
21    builder.filter_module("tether_agent", log::LevelFilter::Warn);
22    builder.filter_module("rumqttc", log::LevelFilter::Warn);
23    builder.init();
24
25    debug!("Debugging is enabled; could be verbose");
26
27    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
28        .id(Some("example"))
29        .build()
30        .expect("failed to init Tether agent");
31
32    let input_one = PlugOptionsBuilder::create_input("one")
33        .build(&mut tether_agent)
34        .expect("failed to create input");
35    info!("input one {} = {}", input_one.name(), input_one.topic());
36    let input_two = PlugOptionsBuilder::create_input("two")
37        .role(Some("specific"))
38        .build(&mut tether_agent)
39        .expect("failed to create input");
40    info!("input two {} = {}", input_two.name(), input_two.topic());
41    let input_empty = PlugOptionsBuilder::create_input("nothing")
42        .build(&mut tether_agent)
43        .expect("failed to create input");
44
45    let input_everything = PlugOptionsBuilder::create_input("everything")
46        .topic(Some("#"))
47        .build(&mut tether_agent)
48        .expect("failed to create input");
49
50    let input_specify_id = PlugOptionsBuilder::create_input("groupMessages")
51        .id(Some("someGroup"))
52        .name(None)
53        .build(&mut tether_agent)
54        .expect("failed to create input");
55
56    debug!(
57        "input everything {} = {}",
58        input_everything.name(),
59        input_everything.topic()
60    );
61
62    info!("Checking messages every 1s, 10x...");
63
64    loop {
65        debug!("Checking for messages...");
66        while let Some((topic, payload)) = tether_agent.check_messages() {
67            // debug!(
68            //     "........ Received a message topic {:?} => topic parts {:?}",
69            //     topic, topic
70            // );
71
72            if input_one.matches(&topic) {
73                info!(
74                            "******** INPUT ONE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
75                            input_one.name(),
76                            topic,
77                            payload.len()
78                        );
79                // assert_eq!(parse_plug_name(topic.un), Some("one"));
80            }
81            if input_two.matches(&topic) {
82                info!(
83                        "******** INPUT TWO:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
84                        input_two.name(),
85                        topic,
86                        payload.len()
87                    );
88                // assert_eq!(parse_plug_name(message.topic()), Some("two"));
89                // assert_ne!(parse_plug_name(message.topic()), Some("one"));
90
91                // Notice how you must give the from_slice function a type so it knows what to expect
92                let decoded = from_slice::<CustomMessage>(&payload);
93                match decoded {
94                    Ok(d) => {
95                        info!("Yes, we decoded the MessagePack payload as: {:?}", d);
96                        let CustomMessage { name, id } = d;
97                        debug!("Name is {} and ID is {}", name, id);
98                    }
99                    Err(e) => {
100                        warn!("Failed to decode the payload: {}", e)
101                    }
102                };
103            }
104            if input_empty.matches(&topic) {
105                info!(
106                        "******** EMPTY MESSAGE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
107                        input_empty.name(),
108                        topic,
109                       payload.len()
110                    );
111                // assert_eq!(parse_plug_name(topic), Some("nothing"));
112            }
113            if input_everything.matches(&topic) {
114                info!(
115                    "******** EVERYTHING MATCHES HERE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
116                    input_everything.name(),
117                    topic,
118                   payload.len()
119                );
120            }
121            if input_specify_id.matches(&topic) {
122                info!("******** ID MATCH:\n Should match any role and plug name, but only messages with ID \"groupMessages\"");
123                info!(
124                    "\n Received a message from plug named \"{}\" on topic {:?} with length {} bytes",
125                    input_specify_id.name(),
126                    topic,
127                    payload.len()
128                );
129                // assert_eq!(parse_agent_id(message.topic()), Some("groupMessages"));
130            }
131        }
132
133        thread::sleep(Duration::from_millis(1000))
134    }
135}

Source

pub fn id(self, id: Option<&str>) -> Self

Optionally sets the Tether ID, as used in auto-generating topics such as myRole/myID/myPlug not the MQTT Client ID. Provide Some(value) to override or None to use the default any (when publishing) or + when subscribing.

Examples found in repository ?

examples/custom_options.rs (line 9)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

More examples

Hide additional examples

examples/subscribe.rs (line 28)

17fn main() {
18    println!("Rust Tether Agent subscribe example");
19
20    let mut builder = Builder::from_env(Env::default().default_filter_or("debug"));
21    builder.filter_module("tether_agent", log::LevelFilter::Warn);
22    builder.filter_module("rumqttc", log::LevelFilter::Warn);
23    builder.init();
24
25    debug!("Debugging is enabled; could be verbose");
26
27    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
28        .id(Some("example"))
29        .build()
30        .expect("failed to init Tether agent");
31
32    let input_one = PlugOptionsBuilder::create_input("one")
33        .build(&mut tether_agent)
34        .expect("failed to create input");
35    info!("input one {} = {}", input_one.name(), input_one.topic());
36    let input_two = PlugOptionsBuilder::create_input("two")
37        .role(Some("specific"))
38        .build(&mut tether_agent)
39        .expect("failed to create input");
40    info!("input two {} = {}", input_two.name(), input_two.topic());
41    let input_empty = PlugOptionsBuilder::create_input("nothing")
42        .build(&mut tether_agent)
43        .expect("failed to create input");
44
45    let input_everything = PlugOptionsBuilder::create_input("everything")
46        .topic(Some("#"))
47        .build(&mut tether_agent)
48        .expect("failed to create input");
49
50    let input_specify_id = PlugOptionsBuilder::create_input("groupMessages")
51        .id(Some("someGroup"))
52        .name(None)
53        .build(&mut tether_agent)
54        .expect("failed to create input");
55
56    debug!(
57        "input everything {} = {}",
58        input_everything.name(),
59        input_everything.topic()
60    );
61
62    info!("Checking messages every 1s, 10x...");
63
64    loop {
65        debug!("Checking for messages...");
66        while let Some((topic, payload)) = tether_agent.check_messages() {
67            // debug!(
68            //     "........ Received a message topic {:?} => topic parts {:?}",
69            //     topic, topic
70            // );
71
72            if input_one.matches(&topic) {
73                info!(
74                            "******** INPUT ONE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
75                            input_one.name(),
76                            topic,
77                            payload.len()
78                        );
79                // assert_eq!(parse_plug_name(topic.un), Some("one"));
80            }
81            if input_two.matches(&topic) {
82                info!(
83                        "******** INPUT TWO:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
84                        input_two.name(),
85                        topic,
86                        payload.len()
87                    );
88                // assert_eq!(parse_plug_name(message.topic()), Some("two"));
89                // assert_ne!(parse_plug_name(message.topic()), Some("one"));
90
91                // Notice how you must give the from_slice function a type so it knows what to expect
92                let decoded = from_slice::<CustomMessage>(&payload);
93                match decoded {
94                    Ok(d) => {
95                        info!("Yes, we decoded the MessagePack payload as: {:?}", d);
96                        let CustomMessage { name, id } = d;
97                        debug!("Name is {} and ID is {}", name, id);
98                    }
99                    Err(e) => {
100                        warn!("Failed to decode the payload: {}", e)
101                    }
102                };
103            }
104            if input_empty.matches(&topic) {
105                info!(
106                        "******** EMPTY MESSAGE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
107                        input_empty.name(),
108                        topic,
109                       payload.len()
110                    );
111                // assert_eq!(parse_plug_name(topic), Some("nothing"));
112            }
113            if input_everything.matches(&topic) {
114                info!(
115                    "******** EVERYTHING MATCHES HERE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
116                    input_everything.name(),
117                    topic,
118                   payload.len()
119                );
120            }
121            if input_specify_id.matches(&topic) {
122                info!("******** ID MATCH:\n Should match any role and plug name, but only messages with ID \"groupMessages\"");
123                info!(
124                    "\n Received a message from plug named \"{}\" on topic {:?} with length {} bytes",
125                    input_specify_id.name(),
126                    topic,
127                    payload.len()
128                );
129                // assert_eq!(parse_agent_id(message.topic()), Some("groupMessages"));
130            }
131        }
132
133        thread::sleep(Duration::from_millis(1000))
134    }
135}

Source

pub fn protocol(self, protocol: Option<&str>) -> Self

Provide Some(value) to override or None to use default

Source

pub fn mqtt_client_id(self, client_id: Option<&str>) -> Self

Optionally set the MQTT Client ID used when connecting to the MQTT broker. This is not the same as the Tether ID used for auto-generating topics.

By default we use a UUID for this value, in order to avoid hard-to-debug issues where Tether Agent instances share the same Client ID and therefore events/messages are not handled properly by all instances.

Source

pub fn host(self, host: Option<&str>) -> Self

Provide Some(value) to override or None to use default

Examples found in repository ?

examples/custom_options.rs (line 10)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

Source

pub fn port(self, port: Option<u16>) -> Self

Examples found in repository ?

examples/custom_options.rs (line 11)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

Source

pub fn username(self, username: Option<&str>) -> Self

Provide Some(value) to override or None to use default

Examples found in repository ?

examples/custom_options.rs (line 12)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

Source

pub fn password(self, password: Option<&str>) -> Self

Provide Some(value) to override or None to use default

Examples found in repository ?

examples/custom_options.rs (line 13)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

Source

pub fn base_path(self, base_path: Option<&str>) -> Self

Provide Some(value) to override or None to use default

Source

pub fn auto_connect(self, should_auto_connect: bool) -> Self

Source

pub fn build(self) -> Result<TetherAgent>

Examples found in repository ?

examples/custom_options.rs (line 14)

7fn main() {
8    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
9        .id(None)
10        .host(Some("localhost"))
11        .port(Some(1883))
12        .username(Some("tether"))
13        .password(Some("sp_ceB0ss!"))
14        .build()
15        .expect("failed to create Tether Agent");
16
17    let output_plug = PlugOptionsBuilder::create_output("anOutput")
18        .role(Some("pretendingToBeSomethingElse"))
19        .qos(Some(2))
20        .retain(Some(true))
21        .build(&mut tether_agent)
22        .expect("failed to create output plug");
23    let input_wildcard_plug = PlugOptionsBuilder::create_input("everything")
24        .topic(Some("#"))
25        .build(&mut tether_agent);
26
27    let input_customid_plug = PlugOptionsBuilder::create_input("someData")
28        .role(None) // i.e., just use default
29        .id(Some("specificIDonly"))
30        .build(&mut tether_agent);
31
32    println!("Agent looks like this: {:?}", tether_agent.description());
33    let (role, id, _) = tether_agent.description();
34    assert_eq!(role, "example");
35    assert_eq!(id, "any"); // because we set None
36
37    if let PlugDefinition::OutputPlug(p) = &output_plug {
38        println!("output plug: {:?}", p);
39        assert_eq!(p.topic_str(), "pretendingToBeSomethingElse/any/anOutput");
40    }
41
42    println!("wildcard input plug: {:?}", input_wildcard_plug);
43    println!("speific ID input plug: {:?}", input_customid_plug);
44
45    let payload =
46        rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
47    tether_agent
48        .publish(&output_plug, Some(&payload))
49        .expect("failed to publish");
50
51    std::thread::sleep(Duration::from_millis(4000));
52}

More examples

Hide additional examples

examples/publish.rs (line 23)

14fn main() {
15    println!("Rust Tether Agent publish example");
16
17    let mut builder = Builder::from_env(Env::default().default_filter_or("info"));
18    builder.init();
19
20    debug!("Debugging is enabled; could be verbose");
21
22    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
23        .build()
24        .expect("failed to connect Tether");
25    let (role, id, _) = tether_agent.description();
26    info!("Created agent OK: {}, {}", role, id);
27
28    let empty_message_output = PlugOptionsBuilder::create_output("nothing")
29        .build(&mut tether_agent)
30        .expect("failed to create output");
31    let boolean_message_output = PlugOptionsBuilder::create_output("one")
32        .build(&mut tether_agent)
33        .expect("failed to create output");
34    let custom_output = PlugOptionsBuilder::create_output("two")
35        .topic(Some("custom/custom/two"))
36        .build(&mut tether_agent)
37        .expect("failed to create output");
38    let grouped_output_1 = PlugOptionsBuilder::create_output("one")
39        .id(Some("groupMessages"))
40        .build(&mut tether_agent)
41        .expect("failed to create output");
42    let grouped_output_2 = PlugOptionsBuilder::create_output("two")
43        .id(Some("groupMessages"))
44        .build(&mut tether_agent)
45        .expect("failed to create output");
46
47    for i in 1..=10 {
48        info!("#{i}: Sending empty message...");
49        tether_agent.publish(&empty_message_output, None).unwrap();
50
51        let bool = i % 2 == 0;
52        info!("#{i}: Sending boolean message...");
53        tether_agent
54            .publish(&boolean_message_output, Some(&[bool.into()]))
55            .unwrap();
56
57        info!("#{i}: Sending custom struct message...");
58        let custom_message = CustomStruct {
59            id: i,
60            name: "hello".into(),
61        };
62        tether_agent
63            .encode_and_publish(&custom_output, custom_message)
64            .unwrap();
65
66        info!("#{i}: Sending grouped messages...");
67        tether_agent.publish(&grouped_output_1, None).unwrap();
68        tether_agent.publish(&grouped_output_2, None).unwrap();
69
70        thread::sleep(Duration::from_millis(1000))
71    }
72}

examples/subscribe.rs (line 29)

17fn main() {
18    println!("Rust Tether Agent subscribe example");
19
20    let mut builder = Builder::from_env(Env::default().default_filter_or("debug"));
21    builder.filter_module("tether_agent", log::LevelFilter::Warn);
22    builder.filter_module("rumqttc", log::LevelFilter::Warn);
23    builder.init();
24
25    debug!("Debugging is enabled; could be verbose");
26
27    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
28        .id(Some("example"))
29        .build()
30        .expect("failed to init Tether agent");
31
32    let input_one = PlugOptionsBuilder::create_input("one")
33        .build(&mut tether_agent)
34        .expect("failed to create input");
35    info!("input one {} = {}", input_one.name(), input_one.topic());
36    let input_two = PlugOptionsBuilder::create_input("two")
37        .role(Some("specific"))
38        .build(&mut tether_agent)
39        .expect("failed to create input");
40    info!("input two {} = {}", input_two.name(), input_two.topic());
41    let input_empty = PlugOptionsBuilder::create_input("nothing")
42        .build(&mut tether_agent)
43        .expect("failed to create input");
44
45    let input_everything = PlugOptionsBuilder::create_input("everything")
46        .topic(Some("#"))
47        .build(&mut tether_agent)
48        .expect("failed to create input");
49
50    let input_specify_id = PlugOptionsBuilder::create_input("groupMessages")
51        .id(Some("someGroup"))
52        .name(None)
53        .build(&mut tether_agent)
54        .expect("failed to create input");
55
56    debug!(
57        "input everything {} = {}",
58        input_everything.name(),
59        input_everything.topic()
60    );
61
62    info!("Checking messages every 1s, 10x...");
63
64    loop {
65        debug!("Checking for messages...");
66        while let Some((topic, payload)) = tether_agent.check_messages() {
67            // debug!(
68            //     "........ Received a message topic {:?} => topic parts {:?}",
69            //     topic, topic
70            // );
71
72            if input_one.matches(&topic) {
73                info!(
74                            "******** INPUT ONE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
75                            input_one.name(),
76                            topic,
77                            payload.len()
78                        );
79                // assert_eq!(parse_plug_name(topic.un), Some("one"));
80            }
81            if input_two.matches(&topic) {
82                info!(
83                        "******** INPUT TWO:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
84                        input_two.name(),
85                        topic,
86                        payload.len()
87                    );
88                // assert_eq!(parse_plug_name(message.topic()), Some("two"));
89                // assert_ne!(parse_plug_name(message.topic()), Some("one"));
90
91                // Notice how you must give the from_slice function a type so it knows what to expect
92                let decoded = from_slice::<CustomMessage>(&payload);
93                match decoded {
94                    Ok(d) => {
95                        info!("Yes, we decoded the MessagePack payload as: {:?}", d);
96                        let CustomMessage { name, id } = d;
97                        debug!("Name is {} and ID is {}", name, id);
98                    }
99                    Err(e) => {
100                        warn!("Failed to decode the payload: {}", e)
101                    }
102                };
103            }
104            if input_empty.matches(&topic) {
105                info!(
106                        "******** EMPTY MESSAGE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
107                        input_empty.name(),
108                        topic,
109                       payload.len()
110                    );
111                // assert_eq!(parse_plug_name(topic), Some("nothing"));
112            }
113            if input_everything.matches(&topic) {
114                info!(
115                    "******** EVERYTHING MATCHES HERE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
116                    input_everything.name(),
117                    topic,
118                   payload.len()
119                );
120            }
121            if input_specify_id.matches(&topic) {
122                info!("******** ID MATCH:\n Should match any role and plug name, but only messages with ID \"groupMessages\"");
123                info!(
124                    "\n Received a message from plug named \"{}\" on topic {:?} with length {} bytes",
125                    input_specify_id.name(),
126                    topic,
127                    payload.len()
128                );
129                // assert_eq!(parse_agent_id(message.topic()), Some("groupMessages"));
130            }
131        }
132
133        thread::sleep(Duration::from_millis(1000))
134    }
135}