Take CASE BUSY delay into account when scheduling retries in Matter.framework. (#32920)

bzbarsky-apple · web-flow · commit ee6c9e9821e8 · 2024-04-10T17:31:32.000Z
diff --git a/src/darwin/Framework/CHIP/MTRBaseDevice.mm b/src/darwin/Framework/CHIP/MTRBaseDevice.mm
@@ -365,7 +365,7 @@ - (void)subscribeWithQueue:(dispatch_queue_t)queue
 
     [self.deviceController getSessionForNode:self.nodeID
                                   completion:^(ExchangeManager * _Nullable exchangeManager, const Optional<SessionHandle> & session,
-                                      NSError * _Nullable error) {
+                                      NSError * _Nullable error, NSNumber * _Nullable retryDelay) {
                                       if (error != nil) {
                                           dispatch_async(queue, ^{
                                               errorHandler(error);
@@ -1603,7 +1603,7 @@ - (void)subscribeToAttributePaths:(NSArray<MTRAttributeRequestPath *> * _Nullabl
     [self.deviceController
         getSessionForNode:self.nodeID
                completion:^(ExchangeManager * _Nullable exchangeManager, const Optional<SessionHandle> & session,
-                   NSError * _Nullable error) {
+                   NSError * _Nullable error, NSNumber * _Nullable retryDelay) {
                    if (error != nil) {
                        dispatch_async(queue, ^{
                            reportHandler(nil, error);
diff --git a/src/darwin/Framework/CHIP/MTRCallbackBridgeBase.h b/src/darwin/Framework/CHIP/MTRCallbackBridgeBase.h
@@ -83,7 +83,7 @@ class MTRCallbackBridgeBase {
 
         [device.deviceController getSessionForCommissioneeDevice:device.nodeID
                                                       completion:^(chip::Messaging::ExchangeManager * exchangeManager,
-                                                          const chip::Optional<chip::SessionHandle> & session, NSError * error) {
+                                                          const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error, NSNumber * _Nullable retryDelay) {
                                                           MaybeDoAction(exchangeManager, session, error);
                                                       }];
     }
@@ -93,8 +93,8 @@ class MTRCallbackBridgeBase {
         LogRequestStart();
 
         [controller getSessionForNode:nodeID
-                           completion:^(chip::Messaging::ExchangeManager * exchangeManager,
-                               const chip::Optional<chip::SessionHandle> & session, NSError * error) {
+                           completion:^(chip::Messaging::ExchangeManager * _Nullable exchangeManager,
+                               const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error, NSNumber * _Nullable retryDelay) {
                                MaybeDoAction(exchangeManager, session, error);
                            }];
     }
diff --git a/src/darwin/Framework/CHIP/MTRDevice.mm b/src/darwin/Framework/CHIP/MTRDevice.mm
@@ -771,7 +771,7 @@ - (void)_handleResubscriptionNeeded
     [self _changeState:MTRDeviceStateUnknown];
 }
 
-- (void)_handleSubscriptionReset
+- (void)_handleSubscriptionReset:(NSNumber * _Nullable)retryDelay
 {
     std::lock_guard lock(_lock);
     // if there is no delegate then also do not retry
@@ -790,17 +790,29 @@ - (void)_handleSubscriptionReset
 
     self.reattemptingSubscription = YES;
 
+    NSTimeInterval secondsToWait;
     if (_lastSubscriptionAttemptWait < MTRDEVICE_SUBSCRIPTION_ATTEMPT_MIN_WAIT_SECONDS) {
         _lastSubscriptionAttemptWait = MTRDEVICE_SUBSCRIPTION_ATTEMPT_MIN_WAIT_SECONDS;
+        secondsToWait = _lastSubscriptionAttemptWait;
+    } else if (retryDelay != nil) {
+        // The device responded but is currently busy. Reset our backoff
+        // counter, so that we don't end up waiting for a long time if the next
+        // attempt fails for some reason, and retry after whatever time period
+        // the device told us to use.
+        _lastSubscriptionAttemptWait = 0;
+        secondsToWait = retryDelay.doubleValue;
+        MTR_LOG_INFO("%@ resetting resubscribe attempt counter, and delaying by the server-provided delay: %f",
+            self, secondsToWait);
     } else {
         _lastSubscriptionAttemptWait *= 2;
         if (_lastSubscriptionAttemptWait > MTRDEVICE_SUBSCRIPTION_ATTEMPT_MAX_WAIT_SECONDS) {
             _lastSubscriptionAttemptWait = MTRDEVICE_SUBSCRIPTION_ATTEMPT_MAX_WAIT_SECONDS;
         }
+        secondsToWait = _lastSubscriptionAttemptWait;
     }
 
-    MTR_LOG_DEFAULT("%@ scheduling to reattempt subscription in %u seconds", self, _lastSubscriptionAttemptWait);
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t) (_lastSubscriptionAttemptWait * NSEC_PER_SEC)), self.queue, ^{
+    MTR_LOG_DEFAULT("%@ scheduling to reattempt subscription in %f seconds", self, secondsToWait);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t) (secondsToWait * NSEC_PER_SEC)), self.queue, ^{
         os_unfair_lock_lock(&self->_lock);
         [self _reattemptSubscriptionNowIfNeeded];
         os_unfair_lock_unlock(&self->_lock);
@@ -1133,12 +1145,13 @@ - (void)_setupSubscription
     [_deviceController
         getSessionForNode:_nodeID.unsignedLongLongValue
                completion:^(chip::Messaging::ExchangeManager * _Nullable exchangeManager,
-                   const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error) {
+                   const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error,
+                   NSNumber * _Nullable retryDelay) {
                    if (error != nil) {
                        MTR_LOG_ERROR("%@ getSessionForNode error %@", self, error);
                        dispatch_async(self.queue, ^{
                            [self _handleSubscriptionError:error];
-                           [self _handleSubscriptionReset];
+                           [self _handleSubscriptionReset:retryDelay];
                        });
                        return;
                    }
@@ -1193,7 +1206,7 @@ - (void)_setupSubscription
 
                            dispatch_async(self.queue, ^{
                                // OnDone
-                               [self _handleSubscriptionReset];
+                               [self _handleSubscriptionReset:nil];
                            });
                            os_unfair_lock_unlock(&self->_lock);
                        },
@@ -1300,7 +1313,7 @@ - (void)_setupSubscription
                        MTR_LOG_ERROR("%@ SendAutoResubscribeRequest error %@", self, error);
                        dispatch_async(self.queue, ^{
                            [self _handleSubscriptionError:error];
-                           [self _handleSubscriptionReset];
+                           [self _handleSubscriptionReset:nil];
                        });
 
                        return;
diff --git a/src/darwin/Framework/CHIP/MTRDeviceConnectionBridge.h b/src/darwin/Framework/CHIP/MTRDeviceConnectionBridge.h
@@ -19,6 +19,7 @@
 
 #import <Foundation/Foundation.h>
 
+#include <app/OperationalSessionSetup.h>
 #include <controller/CHIPDeviceController.h>
 #include <lib/core/ReferenceCounted.h>
 #include <messaging/ExchangeMgr.h>
@@ -27,9 +28,12 @@
 NS_ASSUME_NONNULL_BEGIN
 
 // Either exchangeManager will be non-nil and session will have a value, or
-// error will be non-nil.
+// error will be non-nil.  If error is non-nil, retryDelay might be non-nil.  In
+// that case it will contain an NSTimeInterval indicating how long consumers
+// should delay before trying again (e.g. based on the information communicated
+// in a BUSY response).
 typedef void (^MTRInternalDeviceConnectionCallback)(chip::Messaging::ExchangeManager * _Nullable exchangeManager,
-    const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error);
+    const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error, NSNumber * _Nullable retryDelay);
 
 /**
  * Helper to establish or look up a CASE session and hand its session
@@ -62,11 +66,11 @@ class MTRDeviceConnectionBridge : public chip::ReferenceCounted<MTRDeviceConnect
 private:
     MTRInternalDeviceConnectionCallback mCompletionHandler;
     chip::Callback::Callback<chip::OnDeviceConnected> mOnConnected;
-    chip::Callback::Callback<chip::OnDeviceConnectionFailure> mOnConnectFailed;
+    chip::Callback::Callback<chip::OperationalSessionSetup::OnSetupFailure> mOnConnectFailed;
 
     static void OnConnected(
         void * context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle);
-    static void OnConnectionFailure(void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error);
+    static void OnConnectionFailure(void * context, const chip::OperationalSessionSetup::ConnnectionFailureInfo & failureInfo);
 };
 
 NS_ASSUME_NONNULL_END
diff --git a/src/darwin/Framework/CHIP/MTRDeviceConnectionBridge.mm b/src/darwin/Framework/CHIP/MTRDeviceConnectionBridge.mm
@@ -23,13 +23,17 @@
     void * context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle)
 {
     auto * object = static_cast<MTRDeviceConnectionBridge *>(context);
-    object->mCompletionHandler(&exchangeMgr, chip::MakeOptional<chip::SessionHandle>(*sessionHandle->AsSecureSession()), nil);
+    object->mCompletionHandler(&exchangeMgr, chip::MakeOptional<chip::SessionHandle>(*sessionHandle->AsSecureSession()), nil, nil);
     object->Release();
 }
 
-void MTRDeviceConnectionBridge::OnConnectionFailure(void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error)
+void MTRDeviceConnectionBridge::OnConnectionFailure(void * context, const chip::OperationalSessionSetup::ConnnectionFailureInfo & failureInfo)
 {
+    NSNumber * retryDelay;
+    if (failureInfo.requestedBusyDelay.HasValue()) {
+        retryDelay = @(static_cast<double>(failureInfo.requestedBusyDelay.Value().count()) / MSEC_PER_SEC);
+    }
     auto * object = static_cast<MTRDeviceConnectionBridge *>(context);
-    object->mCompletionHandler(nil, chip::NullOptional, [MTRError errorForCHIPErrorCode:error]);
+    object->mCompletionHandler(nil, chip::NullOptional, [MTRError errorForCHIPErrorCode:failureInfo.error], retryDelay);
     object->Release();
 }
diff --git a/src/darwin/Framework/CHIP/MTRDeviceController.mm b/src/darwin/Framework/CHIP/MTRDeviceController.mm
@@ -1205,7 +1205,7 @@ - (void)getSessionForNode:(chip::NodeId)nodeID completion:(MTRInternalDeviceConn
             connectionBridge->connect(commissioner, nodeID);
         }
         errorHandler:^(NSError * error) {
-            completion(nullptr, chip::NullOptional, error);
+            completion(nullptr, chip::NullOptional, error, nil);
         }];
 }
 
@@ -1216,20 +1216,20 @@ - (void)getSessionForCommissioneeDevice:(chip::NodeId)deviceID completion:(MTRIn
             chip::CommissioneeDeviceProxy * deviceProxy;
             CHIP_ERROR err = commissioner->GetDeviceBeingCommissioned(deviceID, &deviceProxy);
             if (err != CHIP_NO_ERROR) {
-                completion(nullptr, chip::NullOptional, [MTRError errorForCHIPErrorCode:err]);
+                completion(nullptr, chip::NullOptional, [MTRError errorForCHIPErrorCode:err], nil);
                 return;
             }
 
             chip::Optional<chip::SessionHandle> session = deviceProxy->GetSecureSession();
             if (!session.HasValue() || !session.Value()->AsSecureSession()->IsPASESession()) {
-                completion(nullptr, chip::NullOptional, [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE]);
+                completion(nullptr, chip::NullOptional, [MTRError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
                 return;
             }
 
-            completion(deviceProxy->GetExchangeManager(), session, nil);
+            completion(deviceProxy->GetExchangeManager(), session, nil, nil);
         }
         errorHandler:^(NSError * error) {
-            completion(nullptr, chip::NullOptional, error);
+            completion(nullptr, chip::NullOptional, error, nil);
         }];
 }
 
@@ -1609,7 +1609,7 @@ - (BOOL)getBaseDevice:(uint64_t)deviceID queue:(dispatch_queue_t)queue completio
     // that we are running.
     [self getSessionForNode:deviceID
                  completion:^(chip::Messaging::ExchangeManager * _Nullable exchangeManager,
-                     const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error) {
+                     const chip::Optional<chip::SessionHandle> & session, NSError * _Nullable error, NSNumber * _Nullable retryDelay) {
                      // Create an MTRBaseDevice for the node id involved, now that our
                      // CASE session is primed.  We don't actually care about the session
                      // information here.

Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,17 @@`
`23`	`23`	`void * context, chip::Messaging::ExchangeManager & exchangeMgr, const chip::SessionHandle & sessionHandle)`
`24`	`24`	`{`
`25`	`25`	`auto * object = static_cast<MTRDeviceConnectionBridge *>(context);`
`26`		`- object->mCompletionHandler(&exchangeMgr, chip::MakeOptional<chip::SessionHandle>(*sessionHandle->AsSecureSession()), nil);`
	`26`	`+ object->mCompletionHandler(&exchangeMgr, chip::MakeOptional<chip::SessionHandle>(*sessionHandle->AsSecureSession()), nil, nil);`
`27`	`27`	`object->Release();`
`28`	`28`	`}`
`29`	`29`
`30`		`-void MTRDeviceConnectionBridge::OnConnectionFailure(void * context, const chip::ScopedNodeId & peerId, CHIP_ERROR error)`
	`30`	`+void MTRDeviceConnectionBridge::OnConnectionFailure(void * context, const chip::OperationalSessionSetup::ConnnectionFailureInfo & failureInfo)`
`31`	`31`	`{`
	`32`	`+ NSNumber * retryDelay;`
	`33`	`+ if (failureInfo.requestedBusyDelay.HasValue()) {`
	`34`	`+ retryDelay = @(static_cast<double>(failureInfo.requestedBusyDelay.Value().count()) / MSEC_PER_SEC);`
	`35`	`+ }`
`32`	`36`	`auto * object = static_cast<MTRDeviceConnectionBridge *>(context);`
`33`		`- object->mCompletionHandler(nil, chip::NullOptional, [MTRError errorForCHIPErrorCode:error]);`
	`37`	`+ object->mCompletionHandler(nil, chip::NullOptional, [MTRError errorForCHIPErrorCode:failureInfo.error], retryDelay);`
`34`	`38`	`object->Release();`
`35`	`39`	`}`