Added support for explicit current state request

OleksandrChaika · OleksandrChaika · commit 46ffb60876fb · 2023-01-12T17:38:12.000+01:00
diff --git a/docs/testing/mqtt/current-state-get.json b/docs/testing/mqtt/current-state-get.json
@@ -0,0 +1,4 @@
+{
+    "activityId": "random-uuid-as-string",
+    "timestamp": 123456789
+}
diff --git a/src/FSM/States/SendCurrentState.cpp b/src/FSM/States/SendCurrentState.cpp
@@ -0,0 +1,38 @@
+//    Copyright 2022 Contributors to the Eclipse Foundation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+//    SPDX-License-Identifier: Apache-2.0
+
+#include "FSM/States/SendCurrentState.h"
+#include "FSM/FSM.h"
+#include "Context.h"
+#include "FotaEvent.h"
+
+namespace sua {
+
+    SendCurrentState::SendCurrentState()
+        : SendCurrentState("SendCurrentState")
+    { }
+
+    SendCurrentState::SendCurrentState(const std::string& name)
+        : State(name)
+    { }
+
+    void SendCurrentState::onEnter(Context& ctx)
+    {
+        send(ctx, IMqttProcessor::TOPIC_STATE, "systemVersion", true);
+        ctx.stateMachine->handleEvent(FotaEvent::Waiting);
+    }
+
+} // namespace sua
diff --git a/src/FSM/States/SendCurrentState.h b/src/FSM/States/SendCurrentState.h
@@ -0,0 +1,34 @@
+//    Copyright 2022 Contributors to the Eclipse Foundation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+//    SPDX-License-Identifier: Apache-2.0
+
+#ifndef SDV_SUA_SENDCURRENTSTATE_H
+#define SDV_SUA_SENDCURRENTSTATE_H
+
+#include "FSM/State.h"
+
+namespace sua {
+
+    class SendCurrentState : public State {
+    public:
+        SendCurrentState();
+        SendCurrentState(const std::string& name);
+
+        void onEnter(Context& ctx) override;
+    };
+
+} // namespace sua
+
+#endif
diff --git a/src/FotaEvent.cpp b/src/FotaEvent.cpp
@@ -28,6 +28,7 @@ namespace sua {
             { ConnectivityEstablished   , "ConnectivityEstablished"   },
             { ConnectivityLost          , "ConnectivityLost"          },
             { Start                     , "Start"                     },
+            { GetCurrentState           , "GetCurrentState"           },
             { BundleVersionOK           , "BundleVersionOK"           },
             { BundleVersionUnchanged    , "BundleVersionUnchanged"    },
             { BundleVersionInconsistent , "BundleVersionInconsistent" },
diff --git a/src/FotaEvent.h b/src/FotaEvent.h
@@ -26,6 +26,7 @@ namespace sua {
         ConnectivityEstablished,
         ConnectivityLost,
         Start,
+        GetCurrentState,
         BundleVersionOK,
         BundleVersionUnchanged,
         BundleVersionInconsistent,
diff --git a/src/Mqtt/IMqttMessagingProtocol.h b/src/Mqtt/IMqttMessagingProtocol.h
@@ -27,6 +27,8 @@ namespace sua {
 
         virtual class DesiredState readDesiredState(const std::string & input) = 0;
 
+        virtual class DesiredState readCurrentStateRequest(const std::string & input) = 0;
+
         virtual std::string createMessage(const class Context& ctx, const std::string& name) = 0;
     };
 
diff --git a/src/Mqtt/IMqttProcessor.h b/src/Mqtt/IMqttProcessor.h
@@ -23,9 +23,10 @@ namespace sua {
 
     class IMqttProcessor {
     public:
-        static constexpr const char * TOPIC_START    = "selfupdate/desiredstate";
-        static constexpr const char * TOPIC_FEEDBACK = "selfupdate/desiredstatefeedback";
-        static constexpr const char * TOPIC_STATE    = "selfupdate/currentstate";
+        static constexpr const char * TOPIC_START     = "selfupdate/desiredstate";
+        static constexpr const char * TOPIC_FEEDBACK  = "selfupdate/desiredstatefeedback";
+        static constexpr const char * TOPIC_STATE     = "selfupdate/currentstate";
+        static constexpr const char * TOPIC_STATE_GET = "selfupdate/currentstate/get";
 
         virtual ~IMqttProcessor() = default;
 
diff --git a/src/Mqtt/MqttMessagingProtocolJSON.cpp b/src/Mqtt/MqttMessagingProtocolJSON.cpp
@@ -67,13 +67,23 @@ namespace sua {
         // clang-format on
     }
 
+    DesiredState MqttMessagingProtocolJSON::readCurrentStateRequest(const std::string & input)
+    {
+        // clang-format off
+        DesiredState s;
+        std::stringstream ss(input);
+        nlohmann::json json = nlohmann::json::parse(ss);
+        s.activityId        = json["activityId"];
+        return s;
+        // clang-format on
+    }
+
     std::string MqttMessagingProtocolJSON::createMessage(const class Context& ctx, const std::string& name)
     {
         if(name == "systemVersion") {
             // clang-format off
             const std::string tpl = jsonTemplate(R"(
                 {
-                    "activityId": "{}",
                     "timestamp": {},
                     "payload": {
                         "domains": [
@@ -92,7 +102,7 @@ namespace sua {
             )");
             // clang-format on
 
-            return fmt::format(tpl, ctx.desiredState.activityId, epochTime(), ctx.currentState.version);
+            return fmt::format(tpl, epochTime(), ctx.currentState.version);
         }
 
         if(name == "identifying") {
diff --git a/src/Mqtt/MqttMessagingProtocolJSON.h b/src/Mqtt/MqttMessagingProtocolJSON.h
@@ -25,6 +25,8 @@ namespace sua {
     public:
         DesiredState readDesiredState(const std::string & input) override;
 
+        DesiredState readCurrentStateRequest(const std::string & input) override;
+
         std::string createMessage(const class Context& ctx, const std::string& name) override;
 
     protected:
diff --git a/src/Mqtt/MqttMessagingProtocolYAML.cpp b/src/Mqtt/MqttMessagingProtocolYAML.cpp
@@ -81,6 +81,12 @@ namespace sua {
         // clang-format on
     }
 
+    DesiredState MqttMessagingProtocolYAML::readCurrentStateRequest(const std::string & input)
+    {
+      // ignored, no activity id needed, simply pass empty result and trigger response
+      return {};
+    }
+
     std::string MqttMessagingProtocolYAML::createMessage(const class Context& ctx, const std::string& name)
     {
         Yaml::Node root;
diff --git a/src/Mqtt/MqttMessagingProtocolYAML.h b/src/Mqtt/MqttMessagingProtocolYAML.h
@@ -25,6 +25,8 @@ namespace sua {
     public:
         DesiredState readDesiredState(const std::string & input) override;
 
+        DesiredState readCurrentStateRequest(const std::string & input) override;
+
         std::string createMessage(const class Context& ctx, const std::string& name) override;
     };
 
diff --git a/src/Mqtt/MqttProcessor.cpp b/src/Mqtt/MqttProcessor.cpp
@@ -84,6 +84,7 @@ namespace {
         {
             sua::Logger::trace("MqttCallback::connected");
             _mqttClient.subscribe(sua::IMqttProcessor::TOPIC_START, QUALITY, nullptr, _actionListener);
+            _mqttClient.subscribe(sua::IMqttProcessor::TOPIC_STATE_GET, QUALITY, nullptr, _actionListener);
             _context.stateMachine->handleEvent(sua::FotaEvent::ConnectivityEstablished);
         }
 
@@ -100,7 +101,9 @@ namespace {
             if(msg->get_topic() == sua::IMqttProcessor::TOPIC_START) {
                 _context.desiredState = _context.messagingProtocol->readDesiredState(msg->get_payload_str());
                 _context.stateMachine->handleEvent(sua::FotaEvent::Start);
-                return;
+            } if(msg->get_topic() == sua::IMqttProcessor::TOPIC_STATE_GET) {
+                _context.desiredState = _context.messagingProtocol->readCurrentStateRequest(msg->get_payload_str());
+                _context.stateMachine->handleEvent(sua::FotaEvent::GetCurrentState);
             }
         }
 
diff --git a/src/SelfUpdateAgent.cpp b/src/SelfUpdateAgent.cpp
@@ -21,6 +21,7 @@
 #include "FSM/States/Idle.h"
 #include "FSM/States/Installed.h"
 #include "FSM/States/Installing.h"
+#include "FSM/States/SendCurrentState.h"
 #include "FSM/States/Uninitialized.h"
 #include "FotaEvent.h"
 #include "Logger.h"
@@ -35,43 +36,48 @@ namespace sua {
     {
         // clang-format off
         auto factory = std::make_shared<StateFactory>();
-        factory->addStateT<Connected    >("Connected"    );
-        factory->addStateT<Downloading  >("Downloading"  );
-        factory->addStateT<Failed       >("Failed"       );
-        factory->addStateT<Idle         >("Idle"         );
-        factory->addStateT<Installed    >("Installed"    );
-        factory->addStateT<Installing   >("Installing"   );
-        factory->addStateT<Uninitialized>("Uninitialized");
+        factory->addStateT<Connected       >("Connected"       );
+        factory->addStateT<Downloading     >("Downloading"     );
+        factory->addStateT<Failed          >("Failed"          );
+        factory->addStateT<Idle            >("Idle"            );
+        factory->addStateT<Installed       >("Installed"       );
+        factory->addStateT<Installing      >("Installing"      );
+        factory->addStateT<SendCurrentState>("SendCurrentState");
+        factory->addStateT<Uninitialized   >("Uninitialized"   );
         _context.stateMachine->setFactory(factory);
         // clang-format-on
 
         // clang-format off
         _context.stateMachine->setTransitions({
             // from "Uninitialized"
-            { FotaEvent::ConnectivityEstablished   , "Uninitialized", "Connected"      },
+            { FotaEvent::ConnectivityEstablished, "Uninitialized"   , "Connected"       },
             // from "Connected"
-            { FotaEvent::ConnectivityLost          , "Connected"    , "Uninitialized"  },
-            { FotaEvent::Start                     , "Connected"    , "Failed"          , FotaEvent::BundleVersionUnchanged },
-            { FotaEvent::Start                     , "Connected"    , "Downloading"     , FotaEvent::BundleVersionOK        },
+            { FotaEvent::ConnectivityLost       , "Connected"       , "Uninitialized"   },
+            { FotaEvent::Start                  , "Connected"       , "Failed"           , FotaEvent::BundleVersionUnchanged },
+            { FotaEvent::Start                  , "Connected"       , "Downloading"      , FotaEvent::BundleVersionOK        },
+            { FotaEvent::GetCurrentState        , "Connected"       , "SendCurrentState"},
             // from "Failed"
-            { FotaEvent::ConnectivityLost          , "Failed"       , "Uninitialized"  },
-            { FotaEvent::Waiting                   , "Failed"       , "Idle"           },
+            { FotaEvent::ConnectivityLost       , "Failed"          , "Uninitialized"   },
+            { FotaEvent::Waiting                , "Failed"          , "Idle"            },
             // from "Downloading"
-            { FotaEvent::ConnectivityLost          , "Downloading"  , "Uninitialized"  },
-            { FotaEvent::DownloadStart             , "Downloading"  , "Installing"      , FotaEvent::BundleVersionOK           },
-            { FotaEvent::DownloadStart             , "Downloading"  , "Failed"          , FotaEvent::BundleVersionInconsistent },
-            { FotaEvent::DownloadStart             , "Downloading"  , "Failed"          , FotaEvent::DownloadFailed            },
+            { FotaEvent::ConnectivityLost       , "Downloading"     , "Uninitialized"   },
+            { FotaEvent::DownloadStart          , "Downloading"     , "Installing"       , FotaEvent::BundleVersionOK           },
+            { FotaEvent::DownloadStart          , "Downloading"     , "Failed"           , FotaEvent::BundleVersionInconsistent },
+            { FotaEvent::DownloadStart          , "Downloading"     , "Failed"           , FotaEvent::DownloadFailed            },
             // from "Installing"
-            { FotaEvent::ConnectivityLost          , "Installing"   , "Uninitialized"  },
-            { FotaEvent::InstallStart              , "Installing"   , "Installed"       , FotaEvent::InstallCompleted          },
-            { FotaEvent::InstallStart              , "Installing"   , "Failed"          , FotaEvent::InstallFailed             },
+            { FotaEvent::ConnectivityLost       , "Installing"      , "Uninitialized"   },
+            { FotaEvent::InstallStart           , "Installing"      , "Installed"        , FotaEvent::InstallCompleted          },
+            { FotaEvent::InstallStart           , "Installing"      , "Failed"           , FotaEvent::InstallFailed             },
             // from "Installed"
-            { FotaEvent::ConnectivityLost          , "Installed"    , "Uninitialized"  },
-            { FotaEvent::Waiting                   , "Installed"    , "Idle"           },
+            { FotaEvent::ConnectivityLost       , "Installed"       , "Uninitialized"   },
+            { FotaEvent::Waiting                , "Installed"       , "Idle"            },
             // from "Idle"
-            { FotaEvent::ConnectivityLost          , "Idle"         , "Uninitialized"  },
-            { FotaEvent::Start                     , "Idle"         , "Failed"          , FotaEvent::BundleVersionUnchanged },
-            { FotaEvent::Start                     , "Idle"         , "Downloading"     , FotaEvent::BundleVersionOK        },
+            { FotaEvent::ConnectivityLost       , "Idle"            , "Uninitialized"   },
+            { FotaEvent::Start                  , "Idle"            , "Failed"           , FotaEvent::BundleVersionUnchanged },
+            { FotaEvent::Start                  , "Idle"            , "Downloading"      , FotaEvent::BundleVersionOK        },
+            // from "SendCurrentState"
+            { FotaEvent::ConnectivityLost       , "SendCurrentState", "Uninitialized"   },
+            { FotaEvent::Waiting                , "SendCurrentState", "Idle"            },
         });
         _context.stateMachine->transitTo("Uninitialized");
         // clang-format on
diff --git a/utest/TestMqttMessagingProtocolJSON.cpp b/utest/TestMqttMessagingProtocolJSON.cpp
@@ -66,14 +66,29 @@ namespace {
         EXPECT_EQ(s.bundleVersion, "1.1");
     }
 
+    TEST_F(TestMessagingProtocolJSON, readCurrentStateRequest)
+    {
+        // clang-format off
+        const std::string input = R"(
+            {
+                "activityId": "random-uuid-as-string",
+                "timestamp": 123456789
+            }
+        )";
+        // clang-format on
+
+        const sua::DesiredState s = ProtocolJSON().readCurrentStateRequest(input);
+
+        EXPECT_EQ(s.activityId, "random-uuid-as-string");
+    }
+
     TEST_F(TestMessagingProtocolJSON, createMessage_systemVersion)
     {
         const std::string result = ProtocolJSON().createMessage(ctx, "systemVersion");
 
         // clang-format off
         const std::string expected = R"(
             {
-                "activityId": "id",
                 "timestamp": 42,
                 "payload": {
                     "domains": [

Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,12 @@ namespace sua {`
`81`	`81`	`// clang-format on`
`82`	`82`	`}`
`83`	`83`
	`84`	`+ DesiredState MqttMessagingProtocolYAML::readCurrentStateRequest(const std::string & input)`
	`85`	`+ {`
	`86`	`+ // ignored, no activity id needed, simply pass empty result and trigger response`
	`87`	`+ return {};`
	`88`	`+ }`
	`89`	`+`
`84`	`90`	`std::string MqttMessagingProtocolYAML::createMessage(const class Context& ctx, const std::string& name)`
`85`	`91`	`{`
`86`	`92`	`Yaml::Node root;`
Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,7 @@ namespace {`
`84`	`84`	`{`
`85`	`85`	`sua::Logger::trace("MqttCallback::connected");`
`86`	`86`	`_mqttClient.subscribe(sua::IMqttProcessor::TOPIC_START, QUALITY, nullptr, _actionListener);`
	`87`	`+ _mqttClient.subscribe(sua::IMqttProcessor::TOPIC_STATE_GET, QUALITY, nullptr, _actionListener);`
`87`	`88`	`_context.stateMachine->handleEvent(sua::FotaEvent::ConnectivityEstablished);`
`88`	`89`	`}`
`89`	`90`
`@@ -100,7 +101,9 @@ namespace {`
`100`	`101`	`if(msg->get_topic() == sua::IMqttProcessor::TOPIC_START) {`
`101`	`102`	`_context.desiredState = _context.messagingProtocol->readDesiredState(msg->get_payload_str());`
`102`	`103`	`_context.stateMachine->handleEvent(sua::FotaEvent::Start);`
`103`		`- return;`
	`104`	`+ } if(msg->get_topic() == sua::IMqttProcessor::TOPIC_STATE_GET) {`
	`105`	`+ _context.desiredState = _context.messagingProtocol->readCurrentStateRequest(msg->get_payload_str());`
	`106`	`+ _context.stateMachine->handleEvent(sua::FotaEvent::GetCurrentState);`
`104`	`107`	`}`
`105`	`108`	`}`
`106`	`109`