gRPC: use SCNetworkReachability to quickly end connections when reachability changes (#1843)

The reachability state is not (yet) used to determine whether it's possible to reconnect; rather, the its only use is to quickly end any existing connections. The benefit is potentially quicker reaction to network being disconnected than it would take for the connection to time out.

Author: var-const

FirebaseFirestore.podspec

@@ -41,6 +41,7 @@ Google Cloud Firestore is a NoSQL document database built for automatic scaling,
     'Firestore/third_party/Immutable/Tests/**',
 
     # Exclude alternate implementations for other platforms
+    'Firestore/core/src/firebase/firestore/remote/connectivity_monitor_noop.cc',
     'Firestore/core/src/firebase/firestore/util/filesystem_win.cc',
     'Firestore/core/src/firebase/firestore/util/hard_assert_stdio.cc',
     'Firestore/core/src/firebase/firestore/util/log_stdio.cc',
@@ -56,7 +57,7 @@ Google Cloud Firestore is a NoSQL document database built for automatic scaling,
   s.dependency 'Protobuf', '~> 3.1'
   s.dependency 'nanopb', '~> 0.3.8'
 
-  s.frameworks = 'MobileCoreServices'
+  s.frameworks = 'MobileCoreServices', 'SystemConfiguration'
   s.library = 'c++'
   s.pod_target_xcconfig = {
     'GCC_PREPROCESSOR_DEFINITIONS' =>

Firestore/core/src/firebase/firestore/remote/CMakeLists.txt

@@ -12,6 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+cc_library(
+  firebase_firestore_remote_connectivity_monitor_apple
+  SOURCES
+    connectivity_monitor.cc
+    connectivity_monitor.h
+    connectivity_monitor_apple.mm
+  DEPENDS
+    absl_base
+    firebase_firestore_util
+  EXCLUDE_FROM_ALL
+)
+
+cc_library(
+  firebase_firestore_remote_connectivity_monitor_noop
+  SOURCES
+    connectivity_monitor.cc
+    connectivity_monitor.h
+    connectivity_monitor_noop.cc
+  DEPENDS
+    absl_base
+    firebase_firestore_util
+  EXCLUDE_FROM_ALL
+)
+
+cc_select(
+  firebase_firestore_remote_connectivity_monitor
+  APPLE   firebase_firestore_remote_connectivity_monitor_apple
+  DEFAULT firebase_firestore_remote_connectivity_monitor_noop
+)
+
 cc_library(
   firebase_firestore_remote
   SOURCES
@@ -28,6 +58,7 @@ cc_library(
     firebase_firestore_model
     firebase_firestore_nanopb
     firebase_firestore_protos_nanopb
+    firebase_firestore_remote_connectivity_monitor
     firebase_firestore_util
     grpc
 )

Firestore/core/src/firebase/firestore/remote/connectivity_monitor.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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.
+ */
+
+#include "Firestore/core/src/firebase/firestore/remote/connectivity_monitor.h"
+
+#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+
+namespace firebase {
+namespace firestore {
+namespace remote {
+
+void ConnectivityMonitor::SetInitialStatus(NetworkStatus new_status) {
+  HARD_ASSERT(!status_.has_value(),
+              "SetInitialStatus should only be called once");
+  status_ = new_status;
+}
+
+void ConnectivityMonitor::MaybeInvokeCallbacks(NetworkStatus new_status) {
+  if (new_status == status_) {
+    return;
+  }
+  status_ = new_status;
+
+  for (auto& callback : callbacks_) {
+    callback(status_.value());
+  }
+}
+
+}  // namespace remote
+}  // namespace firestore
+}  // namespace firebase

Firestore/core/src/firebase/firestore/remote/connectivity_monitor.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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.
+ */
+
+#ifndef FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_REMOTE_CONNECTIVITY_MONITOR_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_REMOTE_CONNECTIVITY_MONITOR_H_
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "Firestore/core/src/firebase/firestore/util/async_queue.h"
+#include "absl/types/optional.h"
+
+namespace firebase {
+namespace firestore {
+namespace remote {
+
+/**
+ * A base class for monitoring changes in network connectivity; it is expected
+ * that each platform will have its own system-dependent implementation.
+ */
+class ConnectivityMonitor {
+ public:
+  /**
+   * The set of network states is deliberately simplified -- we only care about
+   * states such that transition between them should break currently
+   * established connections.
+   */
+  enum class NetworkStatus {
+    Unavailable,
+    Available,
+    AvailableViaCellular,
+  };
+
+  using CallbackT = std::function<void(NetworkStatus)>;
+
+  /** Creates a platform-specific connectivity monitor. */
+  static std::unique_ptr<ConnectivityMonitor> Create(
+      util::AsyncQueue* worker_queue);
+
+  explicit ConnectivityMonitor(util::AsyncQueue* worker_queue)
+      : worker_queue_{worker_queue} {
+  }
+
+  virtual ~ConnectivityMonitor() {
+  }
+
+  void AddCallback(CallbackT&& callback) {
+    callbacks_.push_back(std::move(callback));
+  }
+  // TODO(varconst): RemoveCallback.
+
+ protected:
+  // The status may be retrieved asynchronously.
+  void SetInitialStatus(NetworkStatus new_status);
+
+  // Invokes callbacks only if the status changed.
+  void MaybeInvokeCallbacks(NetworkStatus new_status);
+
+  util::AsyncQueue* queue() {
+    return worker_queue_;
+  }
+
+ private:
+  util::AsyncQueue* worker_queue_ = nullptr;
+  std::vector<CallbackT> callbacks_;
+  absl::optional<NetworkStatus> status_;
+};
+
+}  // namespace remote
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_REMOTE_CONNECTIVITY_MONITOR_H_

Firestore/core/src/firebase/firestore/remote/connectivity_monitor_apple.mm

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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.
+ */
+
+#include "Firestore/core/src/firebase/firestore/remote/connectivity_monitor.h"
+
+#if defined(__APPLE__)
+
+#include <SystemConfiguration/SystemConfiguration.h>
+#include <dispatch/dispatch.h>
+#include <netinet/in.h>
+
+#include <memory>
+
+#include "Firestore/core/src/firebase/firestore/util/executor_libdispatch.h"
+#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "Firestore/core/src/firebase/firestore/util/log.h"
+#include "absl/memory/memory.h"
+
+namespace firebase {
+namespace firestore {
+namespace remote {
+
+namespace {
+
+using NetworkStatus = ConnectivityMonitor::NetworkStatus;
+using util::AsyncQueue;
+using util::internal::ExecutorLibdispatch;
+
+NetworkStatus ToNetworkStatus(SCNetworkReachabilityFlags flags) {
+  if (!(flags & kSCNetworkReachabilityFlagsReachable)) {
+    return NetworkStatus::Unavailable;
+  }
+  if (flags & kSCNetworkReachabilityFlagsConnectionRequired) {
+    return NetworkStatus::Unavailable;
+  }
+
+#if TARGET_OS_IPHONE
+  if (flags & kSCNetworkReachabilityFlagsIsWWAN) {
+    return NetworkStatus::AvailableViaCellular;
+  }
+#endif
+  return NetworkStatus::Available;
+}
+
+SCNetworkReachabilityRef CreateReachability() {
+  // Pseudoaddress that monitors internet reachability in general.
+  sockaddr_in any_connection_addr{};
+  any_connection_addr.sin_len = sizeof(any_connection_addr);
+  any_connection_addr.sin_family = AF_INET;
+  return SCNetworkReachabilityCreateWithAddress(
+      nullptr, reinterpret_cast<sockaddr*>(&any_connection_addr));
+}
+
+void OnReachabilityChangedCallback(SCNetworkReachabilityRef /*unused*/,
+                                   SCNetworkReachabilityFlags flags,
+                                   void* raw_this);
+
+}  // namespace
+
+/**
+ * Implementation of `ConnectivityMonitor` based on `SCNetworkReachability`
+ * (iOS/MacOS).
+ */
+class ConnectivityMonitorApple : public ConnectivityMonitor {
+ public:
+  explicit ConnectivityMonitorApple(AsyncQueue* worker_queue)
+      : ConnectivityMonitor{worker_queue}, reachability_{CreateReachability()} {
+    SCNetworkReachabilityFlags flags;
+    if (SCNetworkReachabilityGetFlags(reachability_, &flags)) {
+      SetInitialStatus(ToNetworkStatus(flags));
+    }
+
+    SCNetworkReachabilityContext context{};
+    context.info = this;
+    bool success = SCNetworkReachabilitySetCallback(
+        reachability_, OnReachabilityChangedCallback, &context);
+    if (!success) {
+      LOG_DEBUG("Couldn't set reachability callback");
+      return;
+    }
+
+    // TODO(varconst): 1. Make this at least more robust by adding an enum to
+    // `Executor` that allows asserting on the actual type before casting.
+    // 2. This is an unfortunate, brittle mechanism, see if better alternatives
+    //    come up.
+    // On Apple platforms, the executor implementation must be the
+    // libdispatch-based one.
+    auto executor = static_cast<ExecutorLibdispatch*>(queue()->executor());
+    success = SCNetworkReachabilitySetDispatchQueue(reachability_,
+                                                    executor->dispatch_queue());
+    if (!success) {
+      LOG_DEBUG("Couldn't set reachability queue");
+      return;
+    }
+  }
+
+  ~ConnectivityMonitorApple() {
+    bool success =
+        SCNetworkReachabilitySetDispatchQueue(reachability_, nullptr);
+    if (!success) {
+      LOG_DEBUG("Couldn't unset reachability queue");
+    }
+  }
+
+  void OnReachabilityChanged(SCNetworkReachabilityFlags flags) {
+    queue()->ExecuteBlocking(
+        [this, flags] { MaybeInvokeCallbacks(ToNetworkStatus(flags)); });
+  }
+
+ private:
+  SCNetworkReachabilityRef reachability_;
+};
+
+namespace {
+
+void OnReachabilityChangedCallback(SCNetworkReachabilityRef /*unused*/,
+                                   SCNetworkReachabilityFlags flags,
+                                   void* raw_this) {
+  HARD_ASSERT(raw_this, "Received a null pointer as context");
+  static_cast<ConnectivityMonitorApple*>(raw_this)->OnReachabilityChanged(
+      flags);
+}
+
+}  // namespace
+
+std::unique_ptr<ConnectivityMonitor> ConnectivityMonitor::Create(
+    AsyncQueue* worker_queue) {
+  return absl::make_unique<ConnectivityMonitorApple>(worker_queue);
+}
+
+}  // namespace remote
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // defined(__APPLE__)

Firestore/core/src/firebase/firestore/remote/connectivity_monitor_noop.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018 Google
+ *
+ * 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.
+ */
+
+#include "Firestore/core/src/firebase/firestore/remote/connectivity_monitor.h"
+
+#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "absl/memory/memory.h"
+
+namespace firebase {
+namespace firestore {
+namespace remote {
+
+using util::AsyncQueue;
+
+// Returns the default monitor that does nothing. This is to ensure that
+// build doesn't break on platforms which don't yet implement
+// `ConnectivityMonitor`.
+std::unique_ptr<ConnectivityMonitor> ConnectivityMonitor::Create(
+    AsyncQueue* worker_queue) {
+  return absl::make_unique<ConnectivityMonitor>(worker_queue);
+}
+
+}  // namespace remote
+}  // namespace firestore
+}  // namespace firebase