Added third parameter: MQTT server

client/bin/src/main.rs

@@ -387,107 +387,25 @@ fn main() -> ExitCode {
         2 => {
             let ip = &args[1];
 
-
+            // Read broker URL from environment
-            let mut device_online = check_connection(ip.to_string());
+            let broker = match std::env::var("MQTT_BROKER") {
-            if !device_online {
+                Ok(val) if !val.is_empty() => val,
-                println!("{} not online", ip);
+                _ => {
-               // return ExitCode::FAILURE;
+                    eprintln!("Environment variable MQTT_BROKER not set or empty, MQTT disabled");
-            }
+                    String::new()
-
-            
-
-            let receiver = openweathermap::init_forecast("Mannheim",
-            "metric",
-            "de",
-            "978882ab9dd05e7122ff2b0aef2d3e55",
-            60,1);
-
-            let mut last_data = Option::None;
-            
-            // Test Webcrawler for public transportataion
-            let mut straba_res = straba::fetch_data(Some(true));
-            println!("{:?} {:?}s", straba_res.outbound_station, straba_res.outbound_diff);
-            println!("{:?} {:?}s", straba_res.inbound_station , straba_res.inbound_diff);
-
-            // Initialize MQTT client from MQTT_BROKER env var (else disabled)
-            let mqtt_client: Option<Client> = {
-                // Read broker URL from environment
-                let broker = match std::env::var("MQTT_BROKER") {
-                    Ok(val) if !val.is_empty() => val,
-                    _ => {
-                        eprintln!("Environment variable MQTT_BROKER not set or empty, MQTT disabled");
-                        String::new()
-                    }
-                };
-                if broker.is_empty() {
-                    None
-                } else {
-                    let create_opts = CreateOptionsBuilder::new()
-                        .server_uri(&broker)
-                        .client_id("ledboard_client")
-                        .finalize();
-                    match Client::new(create_opts) {
-                        Ok(cli) => {
-                            let conn_opts = ConnectOptionsBuilder::new()
-                                .keep_alive_interval(Duration::from_secs(20))
-                                .clean_session(true)
-                                .finalize();
-                            match cli.connect(conn_opts) {
-                                Ok(_) => Some(cli),
-                                Err(e) => {
-                                    eprintln!("Failed to connect to MQTT broker '{}': {}", broker, e);
-                                    None
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            eprintln!("Failed to create MQTT client for '{}': {}", broker, e);
-                            None
-                        }
-                    }
                 }
             };
 
-            // Render start
+            return main_function(ip, Some(broker))
-            send_package(ip.to_string(), &last_data, &straba_res);
-            loop {
-                let st_now = SystemTime::now();
-                let seconds = st_now.duration_since(UNIX_EPOCH).unwrap().as_secs();
-                let delay = time::Duration::from_millis(500);
-                thread::sleep(delay);
-                // Only request, if the device is present
-                if device_online == true {
-                    let answer = openweathermap::update_forecast(&receiver);
-                    match answer {
-                        Some(_) => {
-                            last_data = answer;
-                        }
-                        None => {
-            
-                        }
-                    }
-                }
 
-                if (straba_res.request_time + 50) < seconds as i64 {
+        }
-                    device_online = check_connection(ip.to_string());
+         // two argument passed
-                    // request once a minute new data
+         3 => {
-                    if device_online == true {
+            let ip = &args[1];
-                        straba_res = straba::fetch_data(None);
+            let mqtt = &args[2];
-                        println!("Update {:?} {:?}s", straba_res.outbound_station, straba_res.outbound_diff);
+            return main_function(   ip,
-                        println!("Update {:?} {:?}s", straba_res.inbound_station , straba_res.inbound_diff);
+                                    Some(mqtt.to_string())
-                    }
+                                );
-                }
-
-                if device_online == true {
-                    // Render new image
-                    send_package(ip.to_string(), &last_data, &straba_res);
-                    // Publish data to MQTT
-               }
-                 if let Some(ref client) = mqtt_client {
-                        publish_to_mqtt(client, &last_data, &straba_res);
-                    }
-
-            }
         }
         // all the other cases
         _ => {
@@ -497,3 +415,100 @@ fn main() -> ExitCode {
         }
     }
 }
+
+fn main_function(ip: &String, mqttBroker: Option<String>) -> ExitCode {
+    let mut device_online: bool = check_connection(ip.to_string());
+    if !device_online {
+        println!("{} not online", ip);
+        return ExitCode::FAILURE;
+    }
+
+            
+
+    let receiver = openweathermap::init_forecast("Mannheim",
+    "metric",
+    "de",
+    "978882ab9dd05e7122ff2b0aef2d3e55",
+    60,1);
+
+    let mut last_data = Option::None;
+            
+    // Test Webcrawler for public transportataion
+    let mut straba_res = straba::fetch_data(Some(true));
+    println!("{:?} {:?}s", straba_res.outbound_station, straba_res.outbound_diff);
+    println!("{:?} {:?}s", straba_res.inbound_station , straba_res.inbound_diff);
+
+    // Initialize MQTT client from MQTT_BROKER env var (else disabled)
+    let mqtt_client: Option<Client> = {
+        if mqttBroker.is_none() {
+            None
+        } else if mqttBroker.is_some() {
+            let create_opts = CreateOptionsBuilder::new()
+                .server_uri(mqttBroker.clone().unwrap())
+                .client_id("ledboard_client")
+                .finalize();
+            match Client::new(create_opts) {
+                Ok(cli) => {
+                    let conn_opts = ConnectOptionsBuilder::new()
+                        .keep_alive_interval(Duration::from_secs(20))
+                        .clean_session(true)
+                        .finalize();
+                    match cli.connect(conn_opts) {
+                        Ok(_) => Some(cli),
+                        Err(e) => {
+                            eprintln!("Failed to connect to MQTT broker '{}': {}", mqttBroker.clone().unwrap(), e);
+                            None
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Failed to create MQTT client for '{}': {}", mqttBroker.clone().unwrap(), e);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    };
+
+    // Render start
+    send_package(ip.to_string(), &last_data, &straba_res);
+    loop {
+        let st_now = SystemTime::now();
+        let seconds = st_now.duration_since(UNIX_EPOCH).unwrap().as_secs();
+        let delay = time::Duration::from_millis(500);
+        thread::sleep(delay);
+        // Only request, if the device is present
+        if device_online == true {
+            let answer = openweathermap::update_forecast(&receiver);
+            match answer {
+                Some(_) => {
+                    last_data = answer;
+                }
+                None => {
+
+                }
+            }
+        }
+
+        if (straba_res.request_time + 50) < seconds as i64 {
+            device_online = check_connection(ip.to_string());
+            // request once a minute new data
+            if device_online == true {
+                straba_res = straba::fetch_data(None);
+                println!("Update {:?} {:?}s", straba_res.outbound_station, straba_res.outbound_diff);
+                println!("Update {:?} {:?}s", straba_res.inbound_station , straba_res.inbound_diff);
+            }
+        }
+
+        if device_online == true {
+            // Render new image
+            send_package(ip.to_string(), &last_data, &straba_res);
+            // Publish data to MQTT
+       }
+         if let Some(ref client) = mqtt_client {
+                publish_to_mqtt(client, &last_data, &straba_res);
+            }
+
+    }
+}