[polari/gnome-3-32] accountsMonitor: Add :reachable account property

[Florian Müllner <fmuellner src gnome org>]

commit 3aa0b53a6fedb8011461a73ae0243853de87ad08
Author: Florian Müllner <fmuellner gnome org>
Date:   Sun May 12 07:28:45 2019 +0200

    accountsMonitor: Add :reachable account property
    
    The property reflects whether at least one of the account's servers
    can be reached. This will allow for a much less erroneous connectivity
    handling than the rather coarse GNetworkManager:network-available.
    
    https://gitlab.gnome.org/GNOME/polari/merge_requests/120

 src/accountsMonitor.js | 72 ++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 70 insertions(+), 2 deletions(-)
---
diff --git a/src/accountsMonitor.js b/src/accountsMonitor.js
index 8848ef3..47f63c4 100644
--- a/src/accountsMonitor.js
+++ b/src/accountsMonitor.js
@@ -16,6 +16,8 @@ var AccountsMonitor = class {
         this._accounts = new Map();
         this._accountSettings = new Map();
 
+        this._networkMonitor = Gio.NetworkMonitor.get_default();
+
         this._app = Gio.Application.get_default();
 
         if (!this._app.isTestInstance) {
@@ -85,10 +87,12 @@ var AccountsMonitor = class {
         am.dup_valid_accounts().forEach(this._addAccount.bind(this));
 
         am.connect('account-validity-changed', (am, account, valid) => {
-            if (valid)
+            if (valid) {
                 this._addAccount(account);
-            else
+                this._updateAccountReachable(account);
+            } else {
                 this._removeAccount(account);
+            }
         });
         am.connect('account-removed', (am, account) => {
             this._removeAccount(account);
@@ -97,6 +101,14 @@ var AccountsMonitor = class {
         am.connect('account-disabled', this._accountEnabledChanged.bind(this));
 
         this._preparedCallbacks.forEach(callback => callback());
+
+        this._networkMonitor.connect('network-changed',
+            this._onNetworkChanged.bind(this));
+        this._onNetworkChanged();
+    }
+
+    _onNetworkChanged() {
+        this.visibleAccounts.forEach(a => this._updateAccountReachable(a));
     }
 
     _onPrepareShutdown() {
@@ -127,8 +139,13 @@ var AccountsMonitor = class {
             account.connect('notify::connection-status', () => {
                 this.emit('account-status-changed', account);
             });
+        account._reachableNotifyId =
+            account.connect('notify::reachable', () => {
+                this.emit('account-reachable-changed', account);
+            });
         account._visibleNotifyId =
             account.connect('notify::visible', () => {
+                this._updateAccountReachable(account);
                 let signal = account.visible ?
                     'account-shown' : 'account-hidden';
                 this.emit(signal, account);
@@ -147,6 +164,9 @@ var AccountsMonitor = class {
         account.disconnect(account._statusNotifyId);
         delete account._statusNotifyId;
 
+        account.disconnect(account._reachableNotifyId);
+        delete account._reachableNotifyId;
+
         account.disconnect(account._visibleNotifyId);
         delete account._visibleNotifyId;
 
@@ -161,6 +181,36 @@ var AccountsMonitor = class {
         this.emit(signal, account);
         this.emit('accounts-changed');
     }
+
+    async _updateAccountReachable(account) {
+        if (!this._networkMonitor.state_valid)
+            return;
+
+        let servers = account.getServers();
+        for (let s of servers) {
+            let addr = new Gio.NetworkAddress({
+                hostname: s.address,
+                port: s.port
+            });
+
+            account._setReachable(await this._canReach(addr));
+
+            if (account.reachable)
+                break;
+        }
+    }
+
+    _canReach(addr) {
+        return new Promise((resolve) => {
+            this._networkMonitor.can_reach_async(addr, null, (mon, res) => {
+                try {
+                    resolve(this._networkMonitor.can_reach_finish(res));
+                } catch (e) {
+                    resolve(false);
+                }
+            });
+        });
+    }
 };
 Signals.addSignalMethods(AccountsMonitor.prototype);
 
@@ -183,6 +233,11 @@ const PolariAccount = GObject.registerClass({
                                               'predefined',
                                               GObject.ParamFlags.READABLE,
                                               false),
+        reachable: GObject.ParamSpec.boolean('reachable',
+                                             'reachable',
+                                             'reachable',
+                                             GObject.ParamFlags.READABLE,
+                                             false),
         visible: GObject.ParamSpec.boolean('visible',
                                            'visible',
                                            'visible',
@@ -192,6 +247,7 @@ const PolariAccount = GObject.registerClass({
 }, class PolariAccount extends Tp.Account {
     _init(params) {
         this._visible = true;
+        this._reachable = undefined;
 
         this._networksManager = NetworksManager.getDefault();
 
@@ -202,6 +258,18 @@ const PolariAccount = GObject.registerClass({
         return this._networksManager.getAccountIsPredefined(this);
     }
 
+    get reachable() {
+        return this._reachable;
+    }
+
+    _setReachable(reachable) {
+        if (this._reachable == reachable)
+            return;
+
+        this._reachable = reachable;
+        this.notify('reachable');
+    }
+
     get visible() {
         return this._visible;
     }