Use new InfoBuilder API in example

Automatically creates queue names

Author: jonnor

examples/repeat.rs

@@ -4,25 +4,12 @@ extern crate msgflo;
 use msgflo::participant::{ParticipantInfo, Participant, ParticipantPort, InfoBuilder};
 
 fn main() {
-    let info = ParticipantInfo {
-        id: "repeat113".to_string(),
-        role: "repeat".to_string(),
-        component: "rust/Repeat".to_string(),
-        label: Some("Repeats input as-is".to_string()),
-        icon: None,
-        inports: vec! [ ParticipantPort { id: "in".to_string(), queue: "repeat.IN".to_string() } ],
-        outports: vec! [ ParticipantPort { id: "out".to_string(), queue: "repeat.OUT".to_string() } ],
-    };
-
-    let mut c =  InfoBuilder::new("rust/Repeat")
+    let info =  InfoBuilder::new("rust/Repeat")
         .label("Repeats input as-is")
         .inport("in")
-        .inport("out")
+        .outport("out")
         .build();
 
-        //let s = std::str::from_utf8(&body).unwrap();
-        //let json_obj: json::Object = json::decode(s).expect("json parse error");
-
     fn process_repeat(input: Vec<u8>) -> Result<Vec<u8>, Vec<u8>> {
         println!("process_repeat:");
         return Ok(input);

src/participant.rs

@@ -35,7 +35,7 @@ pub struct InfoBuilder {
 impl InfoBuilder {
     pub fn new(component: &str) -> InfoBuilder {
         InfoBuilder {
-            info:  ParticipantInfo { .. Default::default() }
+            info:  ParticipantInfo { component: component.to_string(),  .. Default::default() }
         }
     }
 
@@ -44,6 +44,11 @@ impl InfoBuilder {
         self
     }
 
+    pub fn role(&mut self, role: &str) -> &mut InfoBuilder {
+        self.info.role = role.to_string();
+        self
+    }
+
     pub fn inport(&mut self, id: &str) -> &mut InfoBuilder {
         let port = ParticipantPort { id: id.to_string(), queue: "".to_string() };
         self.info.inports.push(port);
@@ -206,10 +211,10 @@ impl Default for ParticipantOptions {
     }
 }
 
-fn normalize_info(info: &ParticipantInfo, options: &ParticipantOptions) -> ParticipantInfo {
+fn normalize_info(old: &ParticipantInfo, options: &ParticipantOptions) -> ParticipantInfo {
     use rand::{thread_rng, Rng};
 
-    let mut new = info.clone();
+    let mut new = old.clone();
 
     // normalize role name
     if options.role != "" {
@@ -225,15 +230,22 @@ fn normalize_info(info: &ParticipantInfo, options: &ParticipantOptions) -> Parti
     new.id = format!("{}-{}", new.role, id_rnd);
 
     // generate port defaults
-
-    // FIXME: allow to specify queue explicitly
-    //new.inports = 
+    let role = new.role.to_string(); // NOTE: would be nice to be able to pass reference to info?
+    let normalize_port = | o: &ParticipantPort | -> ParticipantPort {
+        let mut p = o.clone();
+        if p.queue == "" {
+            p.queue = default_queue(role.to_string(), p.id.to_string());
+        }
+        return p;
+    };
+    new.inports = old.inports.iter().map(&normalize_port).collect();
+    new.outports = old.outports.iter().map(&normalize_port).collect();
 
     return new;
 }
 
 fn default_queue(role: String, port_name: String) -> String {
-    return role + "." + &port_name.to_uppercase();
+    return format!("{}.{}", role, port_name.to_uppercase());
 }
 
 fn parse(options: &mut ParticipantOptions) {
@@ -253,12 +265,13 @@ fn parse(options: &mut ParticipantOptions) {
 // XXX: seems rust-amqp makes program hangs forever if error occurs / channel is borked?
 // TODO: pass port info in/out of process()
 // TODO: nicer way to declare ports? ideally they are enums not stringly typed?
-pub fn main(p: Participant) {
+pub fn main(orig: Participant) {
 
     let mut options = ParticipantOptions { .. Default::default() };
     parse(&mut options);
 
-    normalize_info(&p.info, &options);
+    let info = normalize_info(&orig.info, &options);
+    let p = Participant { info: info, process: orig.process }; // XXX: hack
 
     let mut c = start_participant(&p, &options);
     println!("{}({}) started", &options.role, &p.info.component);