[bindings] Save binding table in persistent storage

examples/all-clusters-app/all-clusters-common/src/binding-handler.cpp

@@ -24,6 +24,7 @@
 #include "app/server/Server.h"
 #include "controller/InvokeInteraction.h"
 #include "lib/core/CHIPError.h"
+#include "platform/CHIPDeviceLayer.h"
 
 #if defined(ENABLE_CHIP_SHELL)
 #include "lib/shell/Engine.h"
@@ -102,10 +103,21 @@ static void BoundDeviceChangedHandler(const EmberBindingTableEntry & binding, ch
     }
 }
 
-CHIP_ERROR InitBindingHandlers()
+static void InitBindingHandlerInternal(intptr_t arg)
 {
-    chip::BindingManager::GetInstance().SetAppServer(&chip::Server::GetInstance());
+    auto & server = chip::Server::GetInstance();
+    chip::BindingManager::GetInstance().Init(
+        { &server.GetFabricTable(), server.GetCASESessionManager(), &server.GetPersistentStorage() });
     chip::BindingManager::GetInstance().RegisterBoundDeviceChangedHandler(BoundDeviceChangedHandler);
+}
+
+CHIP_ERROR InitBindingHandlers()
+{
+    // The initialization of binding manager will try establishing connection with unicast peers
+    // so it requires the Server instance to be correctly initialized. Post the init function to
+    // the event queue so that everything is ready when initialization is conducted.
+    // TODO: Fix initialization order issue in Matter server.
+    chip::DeviceLayer::PlatformMgr().ScheduleWork(InitBindingHandlerInternal);
 #if defined(ENABLE_CHIP_SHELL)
     RegisterSwitchCommands();
 #endif

examples/light-switch-app/efr32/src/binding-handler.cpp

@@ -22,6 +22,7 @@
 #include "app/clusters/bindings/BindingManager.h"
 #include "app/server/Server.h"
 #include "controller/InvokeInteraction.h"
+#include "platform/CHIPDeviceLayer.h"
 
 #if defined(ENABLE_CHIP_SHELL)
 #include "lib/shell/Engine.h"
@@ -132,6 +133,15 @@ static void RegisterSwitchCommands()
     return;
 }
 #endif // ENABLE_CHIP_SHELL
+
+void InitBindingHandlerInternal(intptr_t arg)
+{
+    auto & server = chip::Server::GetInstance();
+    chip::BindingManager::GetInstance().Init(
+        { &server.GetFabricTable(), server.GetCASESessionManager(), &server.GetPersistentStorage() });
+    chip::BindingManager::GetInstance().RegisterBoundDeviceChangedHandler(LightSwitchChangedHandler);
+}
+
 } // namespace
 
 void SwitchToggleOnOff(intptr_t context)
@@ -169,12 +179,12 @@ void SwitchOnOffOff(intptr_t context)
 
 CHIP_ERROR InitBindingHandler()
 {
-    BindingManager::GetInstance().SetAppServer(&Server::GetInstance());
-    BindingManager::GetInstance().RegisterBoundDeviceChangedHandler(LightSwitchChangedHandler);
-
+    // The initialization of binding manager will try establishing connection with unicast peers
+    // so it requires the Server instance to be correctly initialized. Post the init function to
+    // the event queue so that everything is ready when initialization is conducted.
+    chip::DeviceLayer::PlatformMgr().ScheduleWork(InitBindingHandlerInternal);
 #if defined(ENABLE_CHIP_SHELL)
     RegisterSwitchCommands();
 #endif
-
     return CHIP_NO_ERROR;
 }

examples/tv-casting-app/linux/main.cpp

@@ -132,7 +132,9 @@ static void OnBindingAdded(const EmberBindingTableEntry & binding)
 
 CHIP_ERROR InitBindingHandlers()
 {
-    chip::BindingManager::GetInstance().SetAppServer(&chip::Server::GetInstance());
+    auto & server = chip::Server::GetInstance();
+    chip::BindingManager::GetInstance().Init(
+        { &server.GetFabricTable(), server.GetCASESessionManager(), &server.GetPersistentStorage() });
     ReturnErrorOnFailure(chip::BindingManager::GetInstance().RegisterBindingAddedHandler(OnBindingAdded));
     return CHIP_NO_ERROR;
 }

src/app/clusters/bindings/BindingManager.cpp

@@ -18,19 +18,21 @@
 #include <app/clusters/bindings/BindingManager.h>
 #include <app/util/binding-table.h>
 #include <credentials/FabricTable.h>
+#include <lib/support/CHIPMem.h>
 
 namespace {
 
 class BindingFabricTableDelegate : public chip::FabricTableDelegate
 {
     void OnFabricDeletedFromStorage(chip::CompressedFabricId compressedFabricId, chip::FabricIndex fabricIndex)
     {
-        auto iter = chip::BindingTable::GetInstance().begin();
-        while (iter != chip::BindingTable::GetInstance().end())
+        chip::BindingTable & bindingTable = chip::BindingTable::GetInstance();
+        auto iter                         = bindingTable.begin();
+        while (iter != bindingTable.end())
         {
             if (iter->fabricIndex == fabricIndex)
             {
-                iter = chip::BindingTable::GetInstance().RemoveAt(iter);
+                bindingTable.RemoveAt(iter);
             }
             else
             {
@@ -53,9 +55,9 @@ BindingFabricTableDelegate gFabricTableDelegate;
 
 namespace {
 
-chip::PeerId PeerIdForNode(chip::FabricTable & fabricTable, chip::FabricIndex fabric, chip::NodeId node)
+chip::PeerId PeerIdForNode(chip::FabricTable * fabricTable, chip::FabricIndex fabric, chip::NodeId node)
 {
-    chip::FabricInfo * fabricInfo = fabricTable.FindFabricWithIndex(fabric);
+    chip::FabricInfo * fabricInfo = fabricTable->FindFabricWithIndex(fabric);
     if (fabricInfo == nullptr)
     {
         return chip::PeerId();
@@ -80,20 +82,42 @@ CHIP_ERROR BindingManager::UnicastBindingRemoved(uint8_t bindingEntryId)
     return CHIP_NO_ERROR;
 }
 
-void BindingManager::SetAppServer(Server * appServer)
+CHIP_ERROR BindingManager::Init(const BindingManagerInitParams & params)
 {
-    mAppServer = appServer;
-    mAppServer->GetFabricTable().AddFabricDelegate(&gFabricTableDelegate);
+    VerifyOrReturnError(params.mCASESessionManager != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(params.mFabricTable != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(params.mStorage != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    mInitParams = params;
+    params.mFabricTable->AddFabricDelegate(&gFabricTableDelegate);
+    BindingTable::GetInstance().SetPersistentStorage(params.mStorage);
+    CHIP_ERROR error = BindingTable::GetInstance().LoadFromStorage();
+    if (error != CHIP_NO_ERROR)
+    {
+        // This can happen during first boot of the device.
+        ChipLogProgress(AppServer, "Cannot load binding table: %" CHIP_ERROR_FORMAT, error.Format());
+    }
+    else
+    {
+        for (const EmberBindingTableEntry & entry : BindingTable::GetInstance())
+        {
+            if (entry.type == EMBER_UNICAST_BINDING)
+            {
+                // The CASE connection can also fail if the unicast peer is offline.
+                // There is recovery mechanism to retry connection on-demand so ignore error.
+                (void) UnicastBindingCreated(entry.fabricIndex, entry.nodeId);
+            }
+        }
+    }
+    return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR BindingManager::EstablishConnection(FabricIndex fabric, NodeId node)
 {
-    VerifyOrReturnError(mAppServer != nullptr, CHIP_ERROR_INCORRECT_STATE);
-
-    PeerId peer = PeerIdForNode(mAppServer->GetFabricTable(), fabric, node);
+    VerifyOrReturnError(mInitParams.mCASESessionManager != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    PeerId peer = PeerIdForNode(mInitParams.mFabricTable, fabric, node);
     VerifyOrReturnError(peer.GetNodeId() != kUndefinedNodeId, CHIP_ERROR_NOT_FOUND);
     CHIP_ERROR error =
-        mAppServer->GetCASESessionManager()->FindOrEstablishSession(peer, &mOnConnectedCallback, &mOnConnectionFailureCallback);
+        mInitParams.mCASESessionManager->FindOrEstablishSession(peer, &mOnConnectedCallback, &mOnConnectionFailureCallback);
     if (error == CHIP_ERROR_NO_MEMORY)
     {
         // Release the least recently used entry
@@ -104,11 +128,11 @@ CHIP_ERROR BindingManager::EstablishConnection(FabricIndex fabric, NodeId node)
         if (mPendingNotificationMap.FindLRUConnectPeer(&fabricToRemove, &nodeToRemove) == CHIP_NO_ERROR)
         {
             mPendingNotificationMap.RemoveAllEntriesForNode(fabricToRemove, nodeToRemove);
-            PeerId lruPeer = PeerIdForNode(mAppServer->GetFabricTable(), fabricToRemove, nodeToRemove);
-            mAppServer->GetCASESessionManager()->ReleaseSession(lruPeer);
+            PeerId lruPeer = PeerIdForNode(mInitParams.mFabricTable, fabricToRemove, nodeToRemove);
+            mInitParams.mCASESessionManager->ReleaseSession(lruPeer);
             // Now retry
-            error = mAppServer->GetCASESessionManager()->FindOrEstablishSession(peer, &mOnConnectedCallback,
-                                                                                &mOnConnectionFailureCallback);
+            error =
+                mInitParams.mCASESessionManager->FindOrEstablishSession(peer, &mOnConnectedCallback, &mOnConnectionFailureCallback);
         }
     }
     return error;
@@ -131,7 +155,7 @@ void BindingManager::HandleDeviceConnected(OperationalDeviceProxy * device)
     {
         EmberBindingTableEntry entry = BindingTable::GetInstance().GetAt(pendingNotification.mBindingEntryId);
 
-        PeerId peer = PeerIdForNode(mAppServer->GetFabricTable(), entry.fabricIndex, entry.nodeId);
+        PeerId peer = PeerIdForNode(mInitParams.mFabricTable, entry.fabricIndex, entry.nodeId);
         if (device->GetPeerId() == peer)
         {
             fabricToRemove = entry.fabricIndex;
@@ -152,13 +176,13 @@ void BindingManager::HandleDeviceConnectionFailure(PeerId peerId, CHIP_ERROR err
 {
     // Simply release the entry, the connection will be re-established as needed.
     ChipLogError(AppServer, "Failed to establish connection to node 0x" ChipLogFormatX64, ChipLogValueX64(peerId.GetNodeId()));
-    mAppServer->GetCASESessionManager()->ReleaseSession(peerId);
+    mInitParams.mCASESessionManager->ReleaseSession(peerId);
 }
 
 void BindingManager::FabricRemoved(CompressedFabricId compressedFabricId, FabricIndex fabricIndex)
 {
     mPendingNotificationMap.RemoveAllEntriesForFabric(fabricIndex);
-    mAppServer->GetCASESessionManager()->ReleaseSessionsForFabric(compressedFabricId);
+    mInitParams.mCASESessionManager->ReleaseSessionsForFabric(compressedFabricId);
 }
 
 CHIP_ERROR BindingManager::NotifyBindingAdded(const EmberBindingTableEntry & binding)
@@ -172,18 +196,18 @@ CHIP_ERROR BindingManager::NotifyBindingAdded(const EmberBindingTableEntry & bin
 
 CHIP_ERROR BindingManager::NotifyBoundClusterChanged(EndpointId endpoint, ClusterId cluster, void * context)
 {
-    VerifyOrReturnError(mAppServer != nullptr, CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrReturnError(mInitParams.mFabricTable != nullptr, CHIP_ERROR_INCORRECT_STATE);
 
     for (auto iter = BindingTable::GetInstance().begin(); iter != BindingTable::GetInstance().end(); ++iter)
     {
         if (iter->local == endpoint && (!iter->clusterId.HasValue() || iter->clusterId.Value() == cluster))
         {
             if (iter->type == EMBER_UNICAST_BINDING)
             {
-                FabricInfo * fabricInfo = mAppServer->GetFabricTable().FindFabricWithIndex(iter->fabricIndex);
+                FabricInfo * fabricInfo = mInitParams.mFabricTable->FindFabricWithIndex(iter->fabricIndex);
                 VerifyOrReturnError(fabricInfo != nullptr, CHIP_ERROR_NOT_FOUND);
                 PeerId peer                         = fabricInfo->GetPeerIdForNode(iter->nodeId);
-                OperationalDeviceProxy * peerDevice = mAppServer->GetCASESessionManager()->FindExistingSession(peer);
+                OperationalDeviceProxy * peerDevice = mInitParams.mCASESessionManager->FindExistingSession(peer);
                 if (peerDevice != nullptr && peerDevice->IsConnected() && mBoundDeviceChangedHandler)
                 {
                     // We already have an active connection

src/app/clusters/bindings/BindingManager.h

@@ -21,6 +21,8 @@
 #include <app/clusters/bindings/PendingNotificationMap.h>
 #include <app/server/Server.h>
 #include <app/util/binding-table.h>
+#include <credentials/FabricTable.h>
+#include <lib/core/CHIPPersistentStorageDelegate.h>
 
 namespace chip {
 
@@ -38,6 +40,13 @@ namespace chip {
  */
 using BoundDeviceChangedHandler = void (*)(const EmberBindingTableEntry & binding, DeviceProxy * peer_device, void * context);
 
+struct BindingManagerInitParams
+{
+    FabricTable * mFabricTable               = nullptr;
+    CASESessionManager * mCASESessionManager = nullptr;
+    PersistentStorageDelegate * mStorage     = nullptr;
+};
+
 using BindingAddedHandler = void (*)(const EmberBindingTableEntry & binding);
 
 /**
@@ -72,7 +81,7 @@ class BindingManager
         return CHIP_ERROR_INCORRECT_STATE;
     }
 
-    void SetAppServer(Server * appServer);
+    CHIP_ERROR Init(const BindingManagerInitParams & params);
 
     /*
      * Notifies the BindingManager that a new unicast binding is created.
@@ -124,8 +133,8 @@ class BindingManager
 
     PendingNotificationMap mPendingNotificationMap;
     BoundDeviceChangedHandler mBoundDeviceChangedHandler;
+    BindingManagerInitParams mInitParams;
     BindingAddedHandler mBindingAddedHandler;
-    Server * mAppServer = nullptr;
 
     Callback::Callback<OnDeviceConnected> mOnConnectedCallback;
     Callback::Callback<OnDeviceConnectionFailure> mOnConnectionFailureCallback;

src/app/clusters/bindings/bindings.cpp

@@ -101,6 +101,7 @@ void AddBindingEntry(const TargetStructType & entry, EndpointId localEndpoint)
         CHIP_ERROR err = BindingManager::GetInstance().UnicastBindingCreated(entry.fabricIndex, entry.node.Value());
         if (err != CHIP_NO_ERROR)
         {
+            // Unicast connection failure can happen if peer is offline. We'll retry connection on-demand.
             ChipLogProgress(
                 Zcl, "Binding: Failed to create session for unicast binding to device " ChipLogFormatX64 ": %" CHIP_ERROR_FORMAT,
                 ChipLogValueX64(entry.node.Value()), err.Format());
@@ -187,7 +188,7 @@ CHIP_ERROR BindingTableAccess::WriteBindingTable(const ConcreteDataAttributePath
                 {
                     BindingManager::GetInstance().UnicastBindingRemoved(bindingTableIter.GetIndex());
                 }
-                bindingTableIter = BindingTable::GetInstance().RemoveAt(bindingTableIter);
+                ReturnErrorOnFailure(BindingTable::GetInstance().RemoveAt(bindingTableIter));
             }
             else
             {

src/app/server/Server.h

@@ -92,6 +92,8 @@ class Server
 
     CommissioningWindowManager & GetCommissioningWindowManager() { return mCommissioningWindowManager; }
 
+    PersistentStorageDelegate & GetPersistentStorage() { return mDeviceStorage; }
+
     /**
      * This function send the ShutDown event before stopping
      * the event loop.