[Darwin] MTRDevice should trigger resubscription on connectivity changes

jtung-apple · jtung-apple · commit f08b6d771dc4 · 2024-04-18T09:13:21.000-07:00
diff --git a/src/darwin/Framework/CHIP/MTRDevice.mm b/src/darwin/Framework/CHIP/MTRDevice.mm
@@ -28,6 +28,7 @@
 #import "MTRCommandTimedCheck.h"
 #import "MTRConversion.h"
 #import "MTRDefines_Internal.h"
+#import "MTRDeviceConnectivityMonitor.h"
 #import "MTRDeviceControllerOverXPC.h"
 #import "MTRDeviceController_Internal.h"
 #import "MTRDevice_Internal.h"
@@ -46,6 +47,7 @@
 #include <app/BufferedReadCallback.h>
 #include <app/ClusterStateCache.h>
 #include <app/InteractionModelEngine.h>
+#include <lib/dnssd/ServiceNaming.h>
 #include <platform/LockTracker.h>
 #include <platform/PlatformManager.h>
 
@@ -355,6 +357,7 @@ @implementation MTRDevice {
     // _setupSubscription or via the auto-resubscribe behavior of the
     // ReadClient).  Nil if we have had no such failures.
     NSDate * _Nullable _lastSubscriptionFailureTime;
+    MTRDeviceConnectivityMonitor * _connectivityMonitor;
 }
 
 - (instancetype)initWithNodeID:(NSNumber *)nodeID controller:(MTRDeviceController *)controller
@@ -669,6 +672,9 @@ - (void)invalidate
     // subscription.  In that case, _internalDeviceState will update when the
     // subscription is actually terminated.
 
+    [_connectivityMonitor stopMonitoring];
+    _connectivityMonitor = nil;
+
     os_unfair_lock_unlock(&self->_lock);
 }
 
@@ -861,6 +867,10 @@ - (void)_handleSubscriptionEstablished
 
     [self _changeState:MTRDeviceStateReachable];
 
+    // No need to monitor connectivity after subscription establishment
+    [_connectivityMonitor stopMonitoring];
+    _connectivityMonitor = nil;
+
     os_unfair_lock_unlock(&self->_lock);
 
     os_unfair_lock_lock(&self->_timeSyncLock);
@@ -894,6 +904,9 @@ - (void)_handleResubscriptionNeeded
     // former case we recently had a subscription and do not want to be forcing
     // retries immediately.
     _lastSubscriptionFailureTime = [NSDate now];
+
+    // Set up connectivity monitoring in case network routability changes for the positive, to accellerate resubscription
+    [self _setupConnectivityMonitoring];
 }
 
 - (void)_handleSubscriptionReset:(NSNumber * _Nullable)retryDelay
@@ -1241,6 +1254,39 @@ - (void)_createDataVersionFilterListFromDictionary:(NSDictionary<MTRClusterPath
     *count = maxDataVersionFilterSize;
 }
 
+- (void)_setupConnectivityMonitoring
+{
+    std::lock_guard lock(_lock);
+
+    if (_connectivityMonitor) {
+        // already monitoring
+        return;
+    }
+
+    // Get the required info before setting up the connectivity monitor
+    NSNumber * compressedFabricID = [_deviceController syncGetCompressedFabricID];
+    if (!compressedFabricID) {
+        MTR_LOG_INFO("%@ could not get compressed fabricID", self);
+        return;
+    }
+
+    char instanceName[chip::Dnssd::kMaxOperationalServiceNameSize];
+    chip::PeerId peerId(static_cast<chip::CompressedFabricId>(compressedFabricID.unsignedLongLongValue), static_cast<chip::NodeId>(_nodeID.unsignedLongLongValue));
+    CHIP_ERROR err = chip::Dnssd::MakeInstanceName(instanceName, sizeof(instanceName), peerId);
+    if (err != CHIP_NO_ERROR) {
+        MTR_LOG_ERROR("%@ could not make instance name", self);
+        return;
+    }
+
+    _connectivityMonitor = [[MTRDeviceConnectivityMonitor alloc] initWithInstanceName:[NSString stringWithUTF8String:instanceName]];
+    [_connectivityMonitor startMonitoringWithHandler:^{
+        [self->_deviceController asyncDispatchToMatterQueue:^{
+            [self _triggerResubscribeWithReason:"read-through skipped while not subscribed" nodeLikelyReachable:YES];
+        }
+                                               errorHandler:nil];
+    } queue:_queue];
+}
+
 // assume lock is held
 - (void)_setupSubscription
 {
@@ -1462,6 +1508,9 @@ - (void)_setupSubscription
                    callback->AdoptClusterStateCache(std::move(clusterStateCache));
                    callback.release();
                }];
+
+    // Set up connectivity monitoring in case network becomes routable after any part of the subscription process goes into backoff retries.
+    [self _setupConnectivityMonitoring];
 }
 
 #ifdef DEBUG
diff --git a/src/darwin/Framework/CHIP/MTRDeviceConnectivityMonitor.h b/src/darwin/Framework/CHIP/MTRDeviceConnectivityMonitor.h
@@ -0,0 +1,29 @@
+/**
+ *    Copyright (c) 2023 Project CHIP Authors
+ *
+ *    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.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^MTRDeviceConnectivityMonitorHandler)(void);
+
+@interface MTRDeviceConnectivityMonitor : NSObject
+- (instancetype)initWithInstanceName:(NSString *)instanceName;
+- (void)startMonitoringWithHandler:(MTRDeviceConnectivityMonitorHandler)handler queue:(dispatch_queue_t)queue;
+- (void)stopMonitoring;
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/src/darwin/Framework/CHIP/MTRDeviceConnectivityMonitor.mm b/src/darwin/Framework/CHIP/MTRDeviceConnectivityMonitor.mm
@@ -0,0 +1,247 @@
+/**
+ *    Copyright (c) 2023 Project CHIP Authors
+ *
+ *    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.
+ */
+
+#import "MTRDeviceConnectivityMonitor.h"
+#import "MTRLogging_Internal.h"
+#import "MTRUnfairLock.h"
+
+#import <Network/Network.h>
+#import <dns_sd.h>
+#import <os/lock.h>
+
+@interface MTRDeviceConnectivityMonitor ()
+- (void)handleResolvedHostname:(const char *)hostName port:(uint16_t)port error:(DNSServiceErrorType)error;
+@end
+
+@implementation MTRDeviceConnectivityMonitor {
+    NSString * _instanceName;
+    DNSServiceRef _resolver;
+    NSMutableDictionary<NSString *, nw_connection_t> * _connections;
+
+    MTRDeviceConnectivityMonitorHandler _monitorHandler;
+    dispatch_queue_t _handlerQueue;
+}
+
+namespace {
+constexpr char kLocalDot[] = "local.";
+constexpr char kOperationalType[] = "_matter._tcp";
+}
+
+static dispatch_once_t sConnecitivityMonitorOnceToken;
+static os_unfair_lock sConnectivityMonitorLock;
+static NSUInteger sConnectivityMonitorCount;
+static DNSServiceRef sSharedResolverConnection;
+static dispatch_queue_t sSharedResolverQueue;
+
+- (instancetype)initWithInstanceName:(NSString *)instanceName
+{
+    if (self = [super init]) {
+        dispatch_once(&sConnecitivityMonitorOnceToken, ^{
+            sConnectivityMonitorLock = OS_UNFAIR_LOCK_INIT;
+        });
+        _instanceName = [instanceName copy];
+        _connections = [NSMutableDictionary dictionary];
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    if (_resolver) {
+        DNSServiceRefDeallocate(_resolver);
+    }
+}
+
+- (NSString *)description
+{
+    return [NSString stringWithFormat:@"<MTRDeviceConnectivityMonitor: %@>", _instanceName];
+}
+
++ (DNSServiceRef)_sharedResolverConnection
+{
+    os_unfair_lock_assert_owner(&sConnectivityMonitorLock);
+
+    if (!sSharedResolverConnection) {
+        DNSServiceErrorType dnsError = DNSServiceCreateConnection(&sSharedResolverConnection);
+        if (dnsError) {
+            MTR_LOG_ERROR("MTRDeviceConnectivityMonitor: DNSServiceCreateConnection failed %d", dnsError);
+            return NULL;
+        }
+        sSharedResolverQueue = dispatch_queue_create("MTRDeviceConnectivityMonitor", DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL);
+        dnsError = DNSServiceSetDispatchQueue(sSharedResolverConnection, sSharedResolverQueue);
+        if (dnsError != kDNSServiceErr_NoError) {
+            MTR_LOG_ERROR("%@ cannot set dispatch queue on resolve", self);
+            DNSServiceRefDeallocate(sSharedResolverConnection);
+            sSharedResolverConnection = NULL;
+            sSharedResolverQueue = nil;
+            return NULL;
+        }
+    }
+
+    return sSharedResolverConnection;
+}
+
+- (void)_callHandler
+{
+    os_unfair_lock_assert_owner(&sConnectivityMonitorLock);
+    MTRDeviceConnectivityMonitorHandler handlerToCall = self->_monitorHandler;
+    if (handlerToCall) {
+        dispatch_async(self->_handlerQueue, ^{ handlerToCall(); });
+    }
+}
+
+- (void)handleResolvedHostname:(const char *)hostName port:(uint16_t)port error:(DNSServiceErrorType)error
+{
+    std::lock_guard lock(sConnectivityMonitorLock);
+
+    // dns_sd.h: must check and call deallocate if error is kDNSServiceErr_ServiceNotRunning
+    if (error == kDNSServiceErr_ServiceNotRunning) {
+        MTR_LOG_ERROR("%@ disconnected from dns-sd subsystem", self);
+        [self _stopMonitoring];
+        return;
+    }
+
+    // Create a nw_connection to monitor connectivity if the host name is not being monitored yet
+    NSString * hostNameString = [NSString stringWithUTF8String:hostName];
+    if (!_connections[hostNameString]) {
+        char portString[6];
+        snprintf(portString, sizeof(portString), "%d", ntohs(port));
+        nw_endpoint_t endpoint = nw_endpoint_create_host(hostName, portString);
+        if (!endpoint) {
+            MTR_LOG_ERROR("%@ failed to create endpoint for %s:%s", self, hostName, portString);
+            return;
+        }
+        nw_parameters_t params = nw_parameters_create_secure_udp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION);
+        if (!params) {
+            MTR_LOG_ERROR("%@ failed to create udp parameters", self);
+            return;
+        }
+        nw_connection_t connection = nw_connection_create(endpoint, params);
+        if (!connection) {
+            MTR_LOG_ERROR("%@ failed to create connection for %s:%s", self, hostName, portString);
+            return;
+        }
+        nw_connection_set_queue(connection, sSharedResolverQueue);
+        nw_connection_set_path_changed_handler(connection, ^(nw_path_t _Nonnull path) {
+            nw_path_status_t status = nw_path_get_status(path);
+            if (status == nw_path_status_satisfied) {
+                MTR_LOG_INFO("%@ path is satisfied", self);
+                std::lock_guard lock(sConnectivityMonitorLock);
+                [self _callHandler];
+            }
+        });
+        nw_connection_set_viability_changed_handler(connection, ^(bool viable) {
+            if (viable) {
+                std::lock_guard lock(sConnectivityMonitorLock);
+                MTR_LOG_INFO("%@ connectivity now viable", self);
+                [self _callHandler];
+            }
+        });
+        nw_connection_start(connection);
+    }
+}
+
+static void _resolveReplyCallback(
+    DNSServiceRef sdRef,
+    DNSServiceFlags flags,
+    uint32_t interfaceIndex,
+    DNSServiceErrorType errorCode,
+    const char * fullname,
+    const char * hosttarget,
+    uint16_t port, /* In network byte order */
+    uint16_t txtLen,
+    const unsigned char * txtRecord,
+    void * context)
+{
+    auto * connectivityMonitor = (__bridge MTRDeviceConnectivityMonitor *) context;
+    [connectivityMonitor handleResolvedHostname:hosttarget port:port error:errorCode];
+}
+
+- (void)startMonitoringWithHandler:(MTRDeviceConnectivityMonitorHandler)handler queue:(dispatch_queue_t)queue
+{
+    std::lock_guard lock(sConnectivityMonitorLock);
+
+    MTRDeviceConnectivityMonitorHandler handlerCopy = [handler copy];
+    _monitorHandler = handlerCopy;
+    _handlerQueue = queue;
+
+    // If there's already a resolver running, just return
+    if (_resolver) {
+        MTR_LOG_INFO("%@ connectivity monitor updated handler", self);
+        return;
+    }
+
+    MTR_LOG_INFO("%@ start connectivity monitoring for %@ (%lu monitoring objects)", self, _instanceName, static_cast<unsigned long>(sConnectivityMonitorCount));
+
+    _resolver = [MTRDeviceConnectivityMonitor _sharedResolverConnection];
+    if (!_resolver) {
+        MTR_LOG_ERROR("%@ failed to get shared resolver connection", self);
+        return;
+    }
+    DNSServiceErrorType dnsError = DNSServiceResolve(&_resolver,
+        kDNSServiceFlagsShareConnection,
+        kDNSServiceInterfaceIndexAny,
+        _instanceName.UTF8String,
+        kOperationalType,
+        kLocalDot,
+        _resolveReplyCallback,
+        (__bridge void *) self);
+    if (dnsError != kDNSServiceErr_NoError) {
+        MTR_LOG_ERROR("%@ failed to create resolver", self);
+        return;
+    }
+
+    sConnectivityMonitorCount++;
+}
+
+#define MTRDEVICECONNECTIVITYMONITOR_SHARED_CONNECTION_LINGER_INTERVAL (10)
+
+- (void)_stopMonitoring
+{
+    os_unfair_lock_assert_owner(&sConnectivityMonitorLock);
+    for (NSString * hostName in _connections) {
+        nw_connection_cancel(_connections[hostName]);
+    }
+    [_connections removeAllObjects];
+
+    if (_resolver) {
+        DNSServiceRefDeallocate(_resolver);
+        _resolver = NULL;
+
+        // If no monitor objects exist, schedule to deallocate shared connection and queue
+        sConnectivityMonitorCount--;
+        if (!sConnectivityMonitorCount) {
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t) (MTRDEVICECONNECTIVITYMONITOR_SHARED_CONNECTION_LINGER_INTERVAL * NSEC_PER_SEC)), sSharedResolverQueue, ^{
+                std::lock_guard lock(sConnectivityMonitorLock);
+
+                if (!sConnectivityMonitorCount) {
+                    MTR_LOG_INFO("%@ Closing shared resolver connection", self);
+                    DNSServiceRefDeallocate(sSharedResolverConnection);
+                    sSharedResolverConnection = NULL;
+                    sSharedResolverQueue = nil;
+                }
+            });
+        }
+    }
+}
+
+- (void)stopMonitoring
+{
+    MTR_LOG_INFO("%@ stop connectivity monitoring for %@", self, _instanceName);
+    std::lock_guard lock(sConnectivityMonitorLock);
+    [self _stopMonitoring];
+}
+@end
diff --git a/src/darwin/Framework/CHIP/MTRDeviceController.mm b/src/darwin/Framework/CHIP/MTRDeviceController.mm
@@ -1368,6 +1368,13 @@ - (nullable NSNumber *)compressedFabricID
     return @(_cppCommissioner->GetCompressedFabricId());
 }
 
+- (NSNumber * _Nullable)syncGetCompressedFabricID
+{
+    return [self syncRunOnWorkQueueWithReturnValue:^NSNumber * {
+        return [self compressedFabricID];
+    } error:nil];
+}
+
 - (CHIP_ERROR)isRunningOnFabric:(chip::FabricTable *)fabricTable
                     fabricIndex:(chip::FabricIndex)fabricIndex
                       isRunning:(BOOL *)isRunning
diff --git a/src/darwin/Framework/CHIP/MTRDeviceController_Internal.h b/src/darwin/Framework/CHIP/MTRDeviceController_Internal.h
diff --git a/src/darwin/Framework/Matter.xcodeproj/project.pbxproj b/src/darwin/Framework/Matter.xcodeproj/project.pbxproj
