Preserve internal state if disconnected from MQTT Broker

* Preserve internal state if disconnected from MQTT Broker

* Fix review findings #1

Author: OleksandrChaika

src/Mqtt/MqttProcessor.cpp

@@ -112,7 +112,7 @@ namespace {
             const auto message = msg->get_payload_str();
             const auto topic   = msg->get_topic();
 
-            sua::Logger::trace("Received request, topic={}", topic);
+            sua::Logger::trace("Received message via topic '{}'", topic);
 
             try {
                 if(topic == sua::IMqttProcessor::TOPIC_IDENTIFY) {
@@ -126,20 +126,26 @@ namespace {
                     ctx.desiredState.activityId = c.activityId;
                     ctx.stateMachine->handleEvent(c.event);
                 } else {
-                    sua::Logger::error("Invalid topic: {}", topic);
+                    sua::Logger::error("Invalid topic: '{}'", topic);
                 }
             } catch(const nlohmann::json::parse_error & e) {
-                sua::Logger::error("Invalid request for {}, unable to parse json: {}", topic, e.what());
+                // catch here if request is not a valid json (yaml or xml for example)
+                sua::Logger::error("Unable to parse desired state request (not a valid json?): '{}'", e.what());
             } catch(const nlohmann::json::exception& e) {
+                // catch here if request is incomplete (missing field)
+                // result is lost, extract activityId again and reply IdentificationFailed
                 ctx.desiredState.activityId = nlohmann::json::parse(message).at("activityId");
-                sua::Logger::error("Invalid request for {}: {}", topic, e.what());
+                sua::Logger::error("Incomplete desired state request, unable to identify (incomplete json?): '{}'", e.what());
                 mqtt->send(sua::IMqttProcessor::TOPIC_FEEDBACK, sua::MqttMessage::Identifying);
                 mqtt->send(sua::IMqttProcessor::TOPIC_FEEDBACK, sua::MqttMessage::IdentificationFailed, e.what());
             } catch(const std::logic_error & e) {
-                sua::Logger::error("Invalid request for {}: {}", topic, e.what());
+                // catch here if request is valid json but activityId is empty
+                sua::Logger::error("Invalid desired state request: '{}'", e.what());
             } catch(const std::runtime_error & e) {
+                // catch here if request is incomplete (empty field)
+                // result is lost, extract activityId again and reply IdentificationFailed
                 ctx.desiredState.activityId = nlohmann::json::parse(message).at("activityId");
-                sua::Logger::error("Invalid request for {}: {}", topic, e.what());
+                sua::Logger::error("Malformed desired state request, unable to identify: '{}'", e.what());
                 mqtt->send(sua::IMqttProcessor::TOPIC_FEEDBACK, sua::MqttMessage::Identifying);
                 mqtt->send(sua::IMqttProcessor::TOPIC_FEEDBACK, sua::MqttMessage::IdentificationFailed, e.what());
             }
@@ -214,7 +220,11 @@ namespace sua {
         auto mqtt_message = mqtt::make_message(topic, content);
         mqtt_message->set_qos(QUALITY);
         mqtt_message->set_retained(retained);
-        _client.publish(mqtt_message);
+        try {
+            _client.publish(mqtt_message);
+        } catch(const mqtt::exception& e) {
+            Logger::error("Publish to topic '{}' failed: '{}'", topic, e.what());
+        }
 
         if(!_client.is_connected() || !_client.get_pending_delivery_tokens().empty()) {
             _client.reconnect();

src/SelfUpdateAgent.cpp

@@ -61,39 +61,32 @@ namespace sua {
             { FotaEvent::Identify               , "Connected"       , "Connected"        , FotaEvent::BundleVersionUnchanged    },
             { FotaEvent::GetCurrentState        , "Connected"       , "SendCurrentState"},
             // from "Downloading"
-            { FotaEvent::ConnectivityLost       , "Downloading"     , "Uninitialized"   },
             { FotaEvent::DownloadStart          , "Downloading"     , "Installing"       , FotaEvent::DownloadSucceeded         },
             { FotaEvent::DownloadStart          , "Downloading"     , "Failed"           , FotaEvent::DownloadFailed            },
             { FotaEvent::Rollback               , "Downloading"     , "Idle"            },
             // from "Installing"
-            { FotaEvent::ConnectivityLost       , "Installing"      , "Uninitialized"   },
             { FotaEvent::InstallStart           , "Installing"      , "Installed"        , FotaEvent::InstallCompleted          },
             { FotaEvent::InstallStart           , "Installing"      , "Failed"           , FotaEvent::BundleVersionInconsistent },
             { FotaEvent::InstallStart           , "Installing"      , "Failed"           , FotaEvent::InstallFailed             },
             { FotaEvent::InstallStart           , "Installing"      , "Downloading"      , FotaEvent::InstallFailedFallback     },
             { FotaEvent::Rollback               , "Installing"      , "Idle"            },
             // from "Installed"
-            { FotaEvent::ConnectivityLost       , "Installed"       , "Uninitialized"   },
             { FotaEvent::Activate               , "Installed"       , "Activating"      },
             { FotaEvent::Rollback               , "Installed"       , "Idle"            },
             // from "Activating"
-            { FotaEvent::ConnectivityLost       , "Activating"      , "Uninitialized"   },
             { FotaEvent::Cleanup                , "Activating"      , "Cleaning"        },
             { FotaEvent::Rollback               , "Activating"      , "Idle"            },
             // from "Failed"
-            { FotaEvent::ConnectivityLost       , "Failed"          , "Uninitialized"   },
             { FotaEvent::Cleanup                , "Failed"          , "Cleaning"        },
             { FotaEvent::Rollback               , "Failed"          , "Idle"            },
             // from "Cleaning"
-            { FotaEvent::ConnectivityLost       , "Cleaning"        , "Uninitialized"   },
             { FotaEvent::Waiting                , "Cleaning"        , "Idle"            },
             // from "Idle"
             { FotaEvent::ConnectivityLost       , "Idle"            , "Uninitialized"   },
             { FotaEvent::Identify               , "Idle"            , "Downloading"      , FotaEvent::BundleVersionOK           },
             { FotaEvent::Identify               , "Idle"            , "Failed"           , FotaEvent::BundleVersionUnchanged    },
             { FotaEvent::GetCurrentState        , "Idle"            , "SendCurrentState"},
             // from "SendCurrentState"
-            { FotaEvent::ConnectivityLost       , "SendCurrentState", "Uninitialized"   },
             { FotaEvent::Waiting                , "SendCurrentState", "Idle"            },
         });
         _context.stateMachine->transitTo("Uninitialized");