Struct TetherAgent

Source

pub struct TetherAgent { /* private fields */ }

Implementations§

Source §

pub fn description(&self) -> (String, String, String)

Returns the Agent Role, ID (group), Broker URI

Examples found in repository ?

examples/custom_options.rs (line 32)

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 25)

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}

Source

pub fn broker_uri(&self) -> String

Return the URI (protocol, IP address, port, path) that was used to connect to the MQTT broker

Source

pub fn set_role(&mut self, role: &str)

Source

pub fn set_id(&mut self, id: &str)

Source

pub fn connect(&mut self) -> Result<()>

Self must be mutable in order to create and assign new Client (with Connection)

Source

pub fn check_messages(&self) -> Option<(TetherOrCustomTopic, Vec<u8>)>

If a message is waiting return ThreePartTopic, Message (String, Message) Messages received on topics that are not parseable as Tether Three Part Topics will be returned with the complete Topic string instead

Examples found in repository ?

examples/subscribe.rs (line 66)

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 publish( &self, plug_definition: &PlugDefinition, payload: Option<&[u8]>, ) -> Result<()>

Given a plug definition and a raw (u8 buffer) payload, generate a message on an appropriate topic and with the QOS specified in the Plug Definition

Examples found in repository ?

examples/custom_options.rs (line 48)

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 49)

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}

Source

pub fn encode_and_publish<T: Serialize>( &self, plug_definition: &PlugDefinition, data: T, ) -> Result<()>

Similar to publish but serializes the data automatically before sending

Examples found in repository ?

examples/publish.rs (line 63)

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}