Implement a shared-state cache model.

All resources on the bridge internally use the same json state. Advantages: Different resources are always consistent. Disadvantages: Different objects are no longer thread safe, changes are not transparent.

Implement a shared-state cache model.
All resources on the bridge internally use the same json state. Advantages: Different resources are always consistent. Disadvantages: Different objects are no longer thread safe, changes are not transparent.
Jojo-1000 · Moritz Wirger
1 parent 710ee59b
Showing 15 changed files with 110 additions and 54 deletions
include/hueplusplus/BaseDevice.h
include/hueplusplus/Bridge.h
include/hueplusplus/Group.h
include/hueplusplus/HueDeviceTypes.h
include/hueplusplus/Light.h
include/hueplusplus/ResourceList.h
include/hueplusplus/Sensor.h
include/hueplusplus/SensorList.h
src/BaseDevice.cpp
src/Bridge.cpp
src/Group.cpp
src/HueDeviceTypes.cpp
src/Light.cpp
src/Sensor.cpp
test/test_ResourceList.cpp
@@ -120,6 +120,7 @@ public:
     virtual void refresh(bool force = false);
 protected:
+    BaseDevice(int id, const std::shared_ptr<APICache>& baseCache);
     //! \brief Protected ctor that is used by subclasses.
     //!
     //! \param id Integer that specifies the id of this device
@@ -145,9 +145,11 @@ public:
     //! the bridge. Can be left empty and acquired in \ref requestUsername.
     //! \param handler HttpHandler for communication with the bridge
     //! \param refreshDuration Time between refreshing the cached state.
+    //! \param sharedState Uses a single, shared cache for all objects on the bridge.
     Bridge(const std::string& ip, const int port, const std::string& username,
         std::shared_ptr<const IHttpHandler> handler,
-        std::chrono::steady_clock::duration refreshDuration = std::chrono::seconds(10));
+        std::chrono::steady_clock::duration refreshDuration = std::chrono::seconds(10),
+        bool sharedState = false);
     //! \brief Refreshes the bridge state.
     //!
@@ -265,6 +267,7 @@ private:
     detail::MakeCopyable<SensorList> sensorList;
     detail::MakeCopyable<RuleList> ruleList;
     detail::MakeCopyable<BridgeConfig> bridgeConfig;
+    bool sharedState;
 };
 } // namespace hueplusplus
@@ -41,6 +41,7 @@ namespace hueplusplus
 class Group
 {
 public:
+    Group(int id, const std::shared_ptr<APICache>& baseCache);
     //! \brief Creates group with id
     //! \param id Group id in the bridge
     //! \param commands HueCommandAPI for requests
@@ -46,7 +46,7 @@ public:
     //! \throws HueException when light type is unknown
     //! \throws HueAPIResponseException when response contains an error
     //! \throws nlohmann::json::parse_error when response could not be parsed
-    Light createLight(const nlohmann::json& lightState, int id);
+    Light createLight(const nlohmann::json& lightState, int id, const std::shared_ptr<APICache>& baseCache = {});
 private:
     //! \brief Get color type from light JSON.
@@ -554,6 +554,7 @@ public:
     ///@}
 protected:
+
     //! \brief Protected ctor that is used by \ref Bridge class.
     //!
     //! \param id Integer that specifies the id of this light
@@ -562,6 +563,9 @@ protected:
     //! leaves strategies unset
     Light(int id, const HueCommandAPI& commands);
+
+    Light(int id, const std::shared_ptr<APICache>& baseCache);
+
     //! \brief Protected ctor that is used by \ref Bridge class, also sets
     //! strategies.
     //!
@@ -45,6 +45,9 @@ template &lt;typename Resource, typename IdT&gt;
 class ResourceList
 {
 public:
+    struct SharedStateTag
+    { };
+
     using ResourceType = Resource;
     using IdType = IdT;
     static_assert(std::is_integral<IdType>::value || std::is_same<std::string, IdType>::value,
@@ -57,9 +60,13 @@ public:
     //! \param factory Optional factory function to create Resources.
     //! Necessary if Resource is not constructible as described above.
     ResourceList(std::shared_ptr<APICache> baseCache, const std::string& cacheEntry,
-        std::chrono::steady_clock::duration refreshDuration,
-        const std::function<Resource(IdType, const nlohmann::json&)>& factory = nullptr)
-        : stateCache(baseCache, cacheEntry, refreshDuration), factory(factory), path(stateCache.getRequestPath() + '/')
+        std::chrono::steady_clock::duration refreshDuration, bool sharedState = false,
+        const std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)>& factory
+        = nullptr)
+        : stateCache(std::make_shared<APICache>(baseCache, cacheEntry, refreshDuration)),
+          factory(factory),
+          path(stateCache->getRequestPath() + '/'),
+          sharedState(sharedState)
     { }
     //! \brief Construct ResourceList with a separate cache and optional factory function
     //! \param commands HueCommandAPI for requests
@@ -69,8 +76,12 @@ public:
     //! Necessary if Resource is not constructible as described above.
     ResourceList(const HueCommandAPI& commands, const std::string& path,
         std::chrono::steady_clock::duration refreshDuration,
-        const std::function<Resource(IdType, const nlohmann::json&)>& factory = nullptr)
-        : stateCache(path, commands, refreshDuration), factory(factory), path(path + '/')
+        const std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)>& factory
+        = nullptr)
+        : stateCache(std::make_shared<APICache>(path, commands, refreshDuration)),
+          factory(factory),
+          path(path + '/'),
+          sharedState(false)
     { }
     //! \brief Deleted copy constructor
@@ -79,7 +90,7 @@ public:
     ResourceList& operator=(const ResourceList&) = delete;
     //! \brief Refreshes internal state now
-    void refresh() { stateCache.refresh(); }
+    void refresh() { stateCache->refresh(); }
     //! \brief Get all resources that exist
     //! \returns A vector of references to every Resource
@@ -89,7 +100,7 @@ public:
     //! \throws nlohmann::json::parse_error when response could not be parsed
     std::vector<std::reference_wrapper<Resource>> getAll()
     {
-        nlohmann::json state = stateCache.getValue();
+        nlohmann::json state = stateCache->getValue();
         for (auto it = state.begin(); it != state.end(); ++it)
         {
             get(maybeStoi(it.key()));
@@ -118,7 +129,7 @@ public:
             pos->second.refresh(true);
             return pos->second;
         }
-        const nlohmann::json& state = stateCache.getValue();
+        const nlohmann::json& state = stateCache->getValue();
         std::string key = maybeToString(id);
         if (!state.count(key))
         {
@@ -141,7 +152,7 @@ public:
         {
             return true;
         }
-        return stateCache.getValue().count(maybeToString(id)) != 0;
+        return stateCache->getValue().count(maybeToString(id)) != 0;
     }
     //! \brief Checks whether resource with id exists
@@ -156,7 +167,7 @@ public:
         {
             return true;
         }
-        return stateCache.getValue().count(maybeToString(id)) != 0;
+        return stateCache->getValue().count(maybeToString(id)) != 0;
     }
     //! \brief Removes the resource
@@ -171,7 +182,7 @@ public:
     bool remove(const IdType& id)
     {
         std::string requestPath = path + maybeToString(id);
-        nlohmann::json result = stateCache.getCommandAPI().DELETERequest(
+        nlohmann::json result = stateCache->getCommandAPI().DELETERequest(
             requestPath, nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
         bool success = utils::safeGetMember(result, 0, "success") == requestPath + " deleted";
         auto it = resources.find(id);
@@ -208,11 +219,18 @@ private:
     {
         if (factory)
         {
-            return factory(id, state);
+            return factory(id, state, sharedState ? stateCache : std::shared_ptr<APICache>());
         }
         else
         {
-            return Resource(id, stateCache.getCommandAPI(), stateCache.getRefreshDuration());
+            if (sharedState)
+            {
+                return Resource(id, stateCache);
+            }
+            else
+            {
+                return Resource(id, stateCache->getCommandAPI(), stateCache->getRefreshDuration());
+            }
         }
     }
     // Resource is not constructable
@@ -223,7 +241,7 @@ private:
             throw HueException(FileInfo {__FILE__, __LINE__, __func__},
                 "Resource is not constructable with default parameters, but no factory given");
         }
-        return factory(id, state);
+        return factory(id, state, sharedState ? stateCache : std::shared_ptr<APICache>());
     }
 private:
@@ -233,10 +251,11 @@ private:
     static std::string maybeToString(const IdType& id, std::false_type) { return id; }
 protected:
-    APICache stateCache;
-    std::function<Resource(IdType, const nlohmann::json&)> factory;
+    std::shared_ptr<APICache> stateCache;
+    std::function<Resource(IdType, const nlohmann::json&, const std::shared_ptr<APICache>&)> factory;
     std::string path;
     std::map<IdType, Resource> resources;
+    bool sharedState;
 };
 //! \brief Handles a ResourceList of physical devices which can be searched for
@@ -258,12 +277,12 @@ public:
         requestPath.pop_back();
         if (deviceIds.empty())
         {
-            this->stateCache.getCommandAPI().POSTRequest(
+            this->stateCache->getCommandAPI().POSTRequest(
                 requestPath, nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
         }
         else
         {
-            this->stateCache.getCommandAPI().POSTRequest(
+            this->stateCache->getCommandAPI().POSTRequest(
                 requestPath, nlohmann::json {{"deviceid", deviceIds}}, FileInfo {__FILE__, __LINE__, __func__});
         }
     }
@@ -271,7 +290,7 @@ public:
     //! \brief Get devices found in last search
     NewDeviceList getNewDevices() const
     {
-        nlohmann::json response = this->stateCache.getCommandAPI().GETRequest(
+        nlohmann::json response = this->stateCache->getCommandAPI().GETRequest(
             this->path + "new", nlohmann::json::object(), FileInfo {__FILE__, __LINE__, __func__});
         return NewDeviceList::parse(response);
     }
@@ -306,7 +325,7 @@ public:
         std::string requestPath = this->path;
         // Remove slash
         requestPath.pop_back();
-        nlohmann::json response = this->stateCache.getCommandAPI().POSTRequest(
+        nlohmann::json response = this->stateCache->getCommandAPI().POSTRequest(
             requestPath, params.getRequest(), FileInfo {__FILE__, __LINE__, __func__});
         nlohmann::json id = utils::safeGetMember(response, 0, "success", "id");
         if (id.is_string())
@@ -316,7 +335,7 @@ public:
             {
                 idStr.erase(0, this->path.size());
             }
-            this->stateCache.refresh();
+            this->stateCache->refresh();
             return this->maybeStoi(idStr);
         }
         return typename BaseResourceList::IdType {};
@@ -350,7 +369,7 @@ public:
             pos->second.refresh();
             return pos->second;
         }
-        const nlohmann::json& state = this->stateCache.getValue();
+        const nlohmann::json& state = this->stateCache->getValue();
         std::string key = this->maybeToString(id);
         if (!state.count(key) && id != 0)
         {
@@ -59,6 +59,8 @@ Alert alertFromString(const std::string&amp; s);
 class Sensor : public BaseDevice
 {
 public:
+    Sensor(int id, const std::shared_ptr<APICache>& baseCache);
+
     //! \brief Construct Sensor.
     //! \param id Integer that specifies the id of this sensor
     //! \param commands HueCommandAPI for communication with the bridge
@@ -58,7 +58,7 @@ public:
     template <typename T>
     std::vector<T> getAllByType()
     {
-        nlohmann::json state = this->stateCache.getValue();
+        nlohmann::json state = this->stateCache->getValue();
         std::vector<T> result;
         for (auto it = state.begin(); it != state.end(); ++it)
         {
@@ -91,6 +91,10 @@ bool BaseDevice::setName(const std::string&amp; name)
     return utils::safeGetMember(reply, 0, "success", "/lights/" + std::to_string(id) + "/name").is_string();
 }
+BaseDevice::BaseDevice(int id, const std::shared_ptr<APICache>& baseCache)
+    : id(id), state(baseCache, std::to_string(id), baseCache->getRefreshDuration())
+{ }
+
 BaseDevice::BaseDevice(
     int id, const HueCommandAPI& commands, const std::string& path, std::chrono::steady_clock::duration refreshDuration)
     : id(id), path(path), state(path + std::to_string(id), commands, refreshDuration)
@@ -138,7 +138,7 @@ std::string BridgeFinder::ParseDescription(const std::string&amp; description)
 }
 Bridge::Bridge(const std::string& ip, const int port, const std::string& username,
-    std::shared_ptr<const IHttpHandler> handler, std::chrono::steady_clock::duration refreshDuration)
+    std::shared_ptr<const IHttpHandler> handler, std::chrono::steady_clock::duration refreshDuration, bool sharedState)
     : ip(ip),
       username(username),
       port(port),
@@ -146,15 +146,18 @@ Bridge::Bridge(const std::string&amp; ip, const int port, const std::string&amp; usernam
       refreshDuration(refreshDuration),
       stateCache(std::make_shared<APICache>(
           "", HueCommandAPI(ip, port, username, http_handler), std::chrono::steady_clock::duration::max())),
-      lightList(stateCache, "lights", refreshDuration,
+      lightList(stateCache, "lights", refreshDuration, sharedState,
           [factory = LightFactory(stateCache->getCommandAPI(), refreshDuration)](
-              int id, const nlohmann::json& state) mutable { return factory.createLight(state, id); }),
-      groupList(stateCache, "groups", refreshDuration),
-      scheduleList(stateCache, "schedules", refreshDuration),
-      sceneList(stateCache, "scenes", refreshDuration),
-      sensorList(stateCache, "sensors", refreshDuration),
-      ruleList(stateCache, "rules", refreshDuration),
-      bridgeConfig(stateCache, refreshDuration)
+              int id, const nlohmann::json& state, const std::shared_ptr<APICache>& baseCache) mutable {
+              return factory.createLight(state, id, baseCache);
+          }),
+      groupList(stateCache, "groups", refreshDuration, sharedState),
+      scheduleList(stateCache, "schedules", refreshDuration, sharedState),
+      sceneList(stateCache, "scenes", refreshDuration, sharedState),
+      sensorList(stateCache, "sensors", refreshDuration, sharedState),
+      ruleList(stateCache, "rules", refreshDuration, sharedState),
+      bridgeConfig(stateCache, refreshDuration),
+      sharedState(sharedState)
 { }
 void Bridge::refresh()
@@ -304,13 +307,14 @@ void Bridge::setHttpHandler(std::shared_ptr&lt;const IHttpHandler&gt; handler)
 {
     http_handler = handler;
     stateCache = std::make_shared<APICache>("", HueCommandAPI(ip, port, username, handler), refreshDuration);
-    lightList = LightList(stateCache, "lights", refreshDuration,
-        [factory = LightFactory(stateCache->getCommandAPI(), refreshDuration)](
-            int id, const nlohmann::json& state) mutable { return factory.createLight(state, id); });
-    groupList = GroupList(stateCache, "groups", refreshDuration);
-    scheduleList = ScheduleList(stateCache, "schedules", refreshDuration);
-    sceneList = SceneList(stateCache, "scenes", refreshDuration);
-    sensorList = SensorList(stateCache, "sensors", refreshDuration);
+    lightList = LightList(stateCache, "lights", refreshDuration,sharedState,
+        [factory = LightFactory(stateCache->getCommandAPI(), refreshDuration)](int id, const nlohmann::json& state,
+            const std::shared_ptr<APICache>& baseCache) mutable { return factory.createLight(state, id, baseCache); });
+    groupList = GroupList(stateCache, "groups", refreshDuration, sharedState);
+    scheduleList = ScheduleList(stateCache, "schedules", refreshDuration, sharedState);
+    sceneList = SceneList(stateCache, "scenes", refreshDuration, sharedState);
+    sensorList = SensorList(stateCache, "sensors", refreshDuration, sharedState);
+    ruleList = RuleList(stateCache, "rules", refreshDuration, sharedState);
     bridgeConfig = BridgeConfig(stateCache, refreshDuration);
     stateCache->refresh();
 }
@@ -4,6 +4,10 @@
 namespace hueplusplus
 {
+Group::Group(int id, const std::shared_ptr<APICache>& baseCache)
+    : id(id), state(baseCache, std::to_string(id), baseCache->getRefreshDuration())
+{ }
+
 Group::Group(int id, const HueCommandAPI& commands, std::chrono::steady_clock::duration refreshDuration)
     : id(id), state("/groups/" + std::to_string(id), commands, refreshDuration)
 {
@@ -67,41 +67,46 @@ LightFactory::LightFactory(const HueCommandAPI&amp; commands, std::chrono::steady_cl
       extendedColorTemperature(std::make_shared<ExtendedColorTemperatureStrategy>()),
       simpleColorHue(std::make_shared<SimpleColorHueStrategy>()),
       extendedColorHue(std::make_shared<ExtendedColorHueStrategy>())
-{}
+{ }
-Light LightFactory::createLight(const nlohmann::json& lightState, int id)
+Light LightFactory::createLight(const nlohmann::json& lightState, int id, const std::shared_ptr<APICache>& baseCache)
 {
     std::string type = lightState.value("type", "");
     // Ignore case
     std::transform(type.begin(), type.end(), type.begin(), [](char c) { return std::tolower(c); });
+    Light light = baseCache ? Light(id, baseCache) : Light(id, commands, nullptr, nullptr, nullptr, refreshDuration);
+
     if (type == "on/off light" || type == "on/off plug-in unit")
     {
-        Light light(id, commands, nullptr, nullptr, nullptr, refreshDuration);
         light.colorType = ColorType::NONE;
         return light;
     }
-    else if (type == "dimmable light" || type =="dimmable plug-in unit")
+    else if (type == "dimmable light" || type == "dimmable plug-in unit")
     {
-        Light light(id, commands, simpleBrightness, nullptr, nullptr, refreshDuration);
+        light.setBrightnessStrategy(simpleBrightness);
         light.colorType = ColorType::NONE;
         return light;
     }
     else if (type == "color temperature light")
     {
-        Light light(id, commands, simpleBrightness, simpleColorTemperature, nullptr, refreshDuration);
+        light.setBrightnessStrategy(simpleBrightness);
+        light.setColorTemperatureStrategy(simpleColorTemperature);
         light.colorType = ColorType::TEMPERATURE;
         return light;
     }
     else if (type == "color light")
     {
-        Light light(id, commands, simpleBrightness, nullptr, simpleColorHue, refreshDuration);
+        light.setBrightnessStrategy(simpleBrightness);
+        light.setColorHueStrategy(simpleColorHue);
         light.colorType = getColorType(lightState, false);
         return light;
     }
     else if (type == "extended color light")
     {
-        Light light(id, commands, simpleBrightness, extendedColorTemperature, extendedColorHue, refreshDuration);
+        light.setBrightnessStrategy(simpleBrightness);
+        light.setColorTemperatureStrategy(extendedColorTemperature);
+        light.setColorHueStrategy(extendedColorHue);
         light.colorType = getColorType(lightState, true);
         return light;
     }
@@ -114,6 +114,9 @@ StateTransaction Light::transaction()
 Light::Light(int id, const HueCommandAPI& commands) : Light(id, commands, nullptr, nullptr, nullptr) { }
+Light::Light(int id, const std::shared_ptr<APICache>& baseCache) : BaseDevice(id, baseCache), colorType(ColorType::NONE)
+{ }
+
 Light::Light(int id, const HueCommandAPI& commands, std::shared_ptr<const BrightnessStrategy> brightnessStrategy,
     std::shared_ptr<const ColorTemperatureStrategy> colorTempStrategy,
     std::shared_ptr<const ColorHueStrategy> colorHueStrategy, std::chrono::steady_clock::duration refreshDuration)
@@ -122,6 +125,5 @@ Light::Light(int id, const HueCommandAPI&amp; commands, std::shared_ptr&lt;const Bright
       brightnessStrategy(std::move(brightnessStrategy)),
       colorTemperatureStrategy(std::move(colorTempStrategy)),
       colorHueStrategy(std::move(colorHueStrategy))
-{
-}
+{ }
 } // namespace hueplusplus
@@ -230,6 +230,11 @@ bool Sensor::isPrimary() const
     return primary.is_boolean() && primary.get<bool>();
 }
+Sensor::Sensor(int id, const std::shared_ptr<APICache>& baseCache)
+    : BaseDevice(id, baseCache)
+{ }
+
+
 Sensor::Sensor(int id, const HueCommandAPI& commands, std::chrono::steady_clock::duration refreshDuration)
     : BaseDevice(id, commands, "/sensors/", refreshDuration)
 { }
@@ -32,6 +32,7 @@ using namespace testing;
 class TestResource
 {
 public:
+    TestResource(int id, std::shared_ptr<APICache> baseCache) {}
     TestResource(int id, HueCommandAPI api, std::chrono::steady_clock::duration refreshDuration) : id(id) { }
     void refresh(bool force = false) { }
@@ -47,6 +48,7 @@ public:
 class TestStringResource
 {
 public:
+    TestStringResource(const std::string& id, std::shared_ptr<APICache> baseCache) {}
     TestStringResource(const std::string& id, HueCommandAPI api, std::chrono::steady_clock::duration refreshDuration)
         : id(id)
     { }
@@ -122,8 +124,8 @@ TEST(ResourceList, get)
         const nlohmann::json state = {{"resource", "state"}};
         const nlohmann::json response = {{std::to_string(id), state}};
-        MockFunction<TestResource(int, const nlohmann::json&)> factory;
-        EXPECT_CALL(factory, Call(id, state))
+        MockFunction<TestResource(int, const nlohmann::json&, const std::shared_ptr<APICache>&)> factory;
+        EXPECT_CALL(factory, Call(id, state, std::shared_ptr<APICache>()))
             .WillOnce(Return(TestResource(id, commands, std::chrono::steady_clock::duration::max())));
         ResourceList<TestResource, int> list(
@@ -162,7 +164,7 @@ TEST(ResourceList, get)
     }
     {
         ResourceList<TestResourceFactory, int> list(commands, path, std::chrono::steady_clock::duration::max(),
-            [](int, const nlohmann::json&) { return TestResourceFactory(); });
+            [](int, const nlohmann::json&, const std::shared_ptr<APICache>&) { return TestResourceFactory(); });
         const int id = 2;
         const nlohmann::json response = {{std::to_string(id), {{"resource", "state"}}}};