Rest host fallback

src/AblyRest.php

@@ -1,20 +1,18 @@
 <?php
 namespace Ably;
 
-use Ably\Models\ClientOptions;
-use Ably\Models\PaginatedResult;
-use Ably\Models\HttpPaginatedResponse;
 use Ably\Exceptions\AblyException;
 use Ably\Exceptions\AblyRequestException;
+use Ably\Models\ClientOptions;
+use Ably\Models\HttpPaginatedResponse;
+use Ably\Models\PaginatedResult;
 use Ably\Utils\Miscellaneous;
+
 /**
  * Ably REST client
  */
 class AblyRest {
 
-    const API_VERSION = '1.1';
-    const LIB_VERSION = '1.1.6';
-
     public $options;
     /**
      * Map of agents that will be appended to the agent header.
@@ -28,7 +26,7 @@ class AblyRest {
 
     static function ablyAgentHeader()
     {
-        $sdk_identifier = 'ably-php/'.self::LIB_VERSION;
+        $sdk_identifier = 'ably-php/'.Defaults::LIB_VERSION;
         $runtime_identifier = 'php/'.Miscellaneous::getNumeric(phpversion());
         $agent_header = $sdk_identifier.' '.$runtime_identifier;
         foreach(self::$agents as $agent_identifier => $agent_version) {
@@ -52,9 +50,7 @@ static function ablyAgentHeader()
      */
     public $channels;
 
-    // RSC15f Cached fallback host
-    private $cachedHost = null;
-    private $cachedHostExpires = null;
+    public $host;
 
     /**
      * Constructor
@@ -86,7 +82,7 @@ public function __construct( $options = [] ) {
         $this->auth = new $authClass( $this, $this->options );
         $this->channels = new Channels( $this );
         $this->push = new Push( $this );
-
+        $this->host = new Host($this->options);
         return $this;
     }
 
@@ -116,14 +112,6 @@ public function time() {
         return $res[0];
     }
 
-    /**
-     * Returns local time
-     * @return integer system time in milliseconds
-     */
-    public function systemTime() {
-        return intval( round( microtime(true) * 1000 ) );
-    }
-
     /**
      * Does a GET request, automatically injecting auth headers and handling fallback on server failure
      * @see AblyRest::request()
@@ -155,6 +143,17 @@ public function put( $path, $headers = [], $params = [], $returnHeaders = false,
     public function delete( $path, $headers = [], $params = [], $returnHeaders = false, $auth = true ) {
         return $this->requestInternal( 'DELETE', $path, $headers, $params, $returnHeaders, $auth );
     }
+
+    /**
+     * Returns hosts in the order 1. Cached Host or Primary Host 2. Randomized Fallback Hosts
+     * @return \Generator hosts
+     */
+    public function getHosts() {
+        $prefHost = $this->host->getPreferredHost();
+        yield $prefHost;
+        yield from $this->host->fallbackHosts($prefHost);
+    }
+
     /**
      * Does a HTTP request, automatically injecting auth headers and handling fallback on server failure.
      * This method is used internally and `request` is the preferable method to use.
@@ -169,52 +168,57 @@ public function delete( $path, $headers = [], $params = [], $returnHeaders = fal
      *         body, depending on $returnHeaders, body is automatically decoded
      * @throws AblyRequestException if the request fails
      */
-    public function requestInternal( $method, $path, $headers = [], $params = [], $returnHeaders = false,
-                                     $auth = true ) {
-
+    public function requestInternal( $method, $path, $headers = [], $params = [], $returnHeaders = false, $auth = true ) {
         $mergedHeaders = array_merge( [
             'Accept: application/json',
-            'X-Ably-Version: ' .self::API_VERSION,
+            'X-Ably-Version: ' .Defaults::API_VERSION,
             'Ably-Agent: ' .self::ablyAgentHeader(),
         ], $headers );
-
         if ( $auth ) { // inject auth headers
             $mergedHeaders = array_merge( $this->auth->getAuthHeaders(), $mergedHeaders );
         }
-
-        try {
-            if ( !empty( $this->options->getFallbackHosts() ) ) {
-                $res = $this->requestWithFallback( $method, $path, $mergedHeaders, $params );
-            } else {
-                $hostUrl = $this->options->getHostUrl($this->options->getRestHost()). $path;
-                $res = $this->http->request( $method, $hostUrl , $mergedHeaders, $params );
-            }
-        } catch (AblyRequestException $e) {
-            // check if the exception was caused by an expired
-            // token = authorised request + using token auth + specific error message
-            $res = $e->getResponse();
-
-            $causedByExpiredToken = $auth
-                && !$this->auth->isUsingBasicAuth()
-                && ($e->getCode() >= 40140)
-                && ($e->getCode() < 40150);
-
-            if ( $causedByExpiredToken ) { // renew the token
-                $this->auth->authorize();
-
-                // merge headers now and use auth = false to prevent potential endless recursion
-                $mergedHeaders = array_merge( $this->auth->getAuthHeaders(), $headers );
-
-                return $this->requestInternal($method, $path, $mergedHeaders, $params, $returnHeaders, $auth = false);
-            } else {
-                throw $e;
+        $attempt = 0;
+        $maxPossibleRetries = min(count($this->options->getFallbackHosts()), $this->options->httpMaxRetryCount);
+        foreach ($this->getHosts() as $host) {
+            $hostUrl = $this->options->getHostUrl($host). $path;
+            try {
+                $updatedHeaders = $mergedHeaders;
+                if ($host != $this->options->getPrimaryRestHost()) { // set hostHeader for fallback host (RSC15j)
+                    $updatedHeaders[] = "Host: " . $host;
+                }
+                $response = $this->http->request( $method, $hostUrl, $updatedHeaders, $params );
+                $this->host->setPreferredHost($host);
+                break;
+            } catch (AblyRequestException $e) {
+                $response = $e->getResponse();
+                // Clear cached host if it failed (RSC15f)
+                $this->host->setPreferredHost("");
+
+                $isServerError = $e->getStatusCode() >= 500 && $e->getStatusCode() <= 504; // RSC15d
+                if ( $isServerError && $attempt < $maxPossibleRetries) {
+                    $attempt += 1;
+                } else {
+                    $causedByExpiredToken = $auth && !$this->auth->isUsingBasicAuth()
+                        && ($e->getCode() >= 40140)
+                        && ($e->getCode() < 40150);
+
+                    if ( $causedByExpiredToken ) { // renew the token
+                        $this->auth->authorize();
+
+                        // merge headers now and use auth = false to prevent potential endless recursion
+                        $mergedHeaders = array_merge( $this->auth->getAuthHeaders(), $headers );
+
+                        return $this->requestInternal($method, $path, $mergedHeaders, $params, $returnHeaders, $auth = false);
+                    } else {
+                        throw $e;
+                    }
+                }
             }
         }
-
         if (!$returnHeaders) {
-            $res = $res['body'];
+            $response = $response['body'];
         }
-        return $res;
+        return $response;
     }
 
     /**
@@ -245,66 +249,10 @@ public function request( $method, $path, $params = [], $body = '', $headers = []
         return new HttpPaginatedResponse( $this, 'Ably\Models\Untyped', null, $method, $path, $body, $headers );
     }
 
-    /**
-     * Does a HTTP request backed up by fallback servers
-     */
-    private function getHosts() {
-        // The cached fallback host
-        if ( $this->cachedHost != null ) {
-            if ( $this->systemTime() > $this->cachedHostExpires ) {
-                $this->cachedHost = null;
-                $this->cachedHostExpires = null;
-            } else {
-                yield $this->cachedHost;
-            }
-        }
-
-        // Default host
-        yield $this->options->getRestHost();
-
-        // Fallback hosts
-        foreach ($this->options->getFallbackHosts() as $host) {
-            if ( $host != $this->cachedHost ) { // Don't try twice the same host
-                yield $host;
-            }
-        }
-    }
-
-    protected function requestWithFallback( $method, $path, $headers = [], $params = [] ) {
-        $maxAttempts = min( $this->options->httpMaxRetryCount, count( $this->options->getFallbackHosts() ));
-        $attempt = 0;
-        foreach ($this->getHosts() as $host) {
-            $hostUrl = $this->options->getHostUrl($host). $path;
-            try {
-                $response = $this->http->request( $method, $hostUrl, $headers, $params );
-
-                // Keep fallback host for later (RSC15f)
-                if ( $attempt > 0 && $host != $this->options->getRestHost()) {
-                    $this->cachedHost = $host;
-                    $this->cachedHostExpires = $this->systemTime() + $this->options->fallbackRetryTimeout;
-                }
-
-                return $response;
-            } catch (AblyRequestException $e) {
-                // Clear cached host if it failed (RSC15f)
-                if ( $host == $this->cachedHost ) {
-                    $this->cachedHost = null;
-                    $this->cachedHostExpires = null;
-                }
-
-                // other error code than timeout, rethrow exception
-                if ( $e->getCode() < 50000 ) {
-                    throw $e;
-                }
-
-                if ( $attempt >= $maxAttempts ) {
-                    Log::e( 'Failed to connect to server and all of the fallback servers.' );
-                    throw $e;
-                }
-
-                $attempt += 1;
-            }
-        }
+    // RTN17c
+    function hasActiveInternetConnection() {
+        $response = $this->http->get(Defaults::$internetCheckUrl);
+        return $response["body"] == Defaults::$internetCheckOk;
     }
 
     /**

src/Auth.php

@@ -1,14 +1,12 @@
 <?php
 namespace Ably;
 
-use Ably\AblyRest;
-use Ably\Log;
+use Ably\Exceptions\AblyException;
 use Ably\Models\AuthOptions;
 use Ably\Models\ClientOptions;
 use Ably\Models\TokenDetails;
 use Ably\Models\TokenParams;
 use Ably\Models\TokenRequest;
-use Ably\Exceptions\AblyException;
 
 /**
  * Provides authentification methods for AblyRest instances
@@ -108,7 +106,7 @@ public function authorizeInternal( $tokenParams = [], $authOptions = [], $force
                 // using cached token
                 Log::d( 'Auth::authorize: using cached token, unknown expiration time' );
                 return $this->tokenDetails;
-            } else if ( $this->tokenDetails->expires - self::TOKEN_EXPIRY_MARGIN > $this->ably->systemTime() ) {
+            } else if ( $this->tokenDetails->expires - self::TOKEN_EXPIRY_MARGIN > Utils\Miscellaneous::systemTime()) {
                 // using cached token
                 Log::d( 'Auth::authorize: using cached token, expires on ' . date( 'Y-m-d H:i:s', $this->tokenDetails->expires / 1000 ) );
                 return $this->tokenDetails;
@@ -318,7 +316,7 @@ public function createTokenRequest( $tokenParams = [], $authOptions = [] ) {
         if ( $authOptions->queryTime ) {
             $tokenRequest->timestamp = $this->ably->time();
         } else if ( empty( $tokenRequest->timestamp ) ) {
-            $tokenRequest->timestamp = $this->ably->systemTime();
+            $tokenRequest->timestamp = Utils\Miscellaneous::systemTime();
         }
 
         if ( empty( $tokenRequest->clientId ) ) {

src/Defaults.php

@@ -2,12 +2,17 @@
 namespace Ably;
 
 class Defaults {
+    const API_VERSION = '1.1';
+    const LIB_VERSION = '1.1.6';
 
     static $restHost = "rest.ably.io";
     static $realtimeHost = "realtime.ably.io";
     static $port = 80;
     static $tlsPort = 443;
 
+    static $internetCheckUrl = "https://internet-up.ably-realtime.com/is-the-internet-up.txt";
+    static $internetCheckOk = "yes\n";
+
     static $fallbackHosts = [
         'a.ably-realtime.com',
         'b.ably-realtime.com',

src/Host.php

@@ -0,0 +1,42 @@
+<?php
+namespace Ably;
+
+class Host {
+    private $primaryHost;
+    private $fallbackHosts;
+    private $hostCache;
+
+    public function __construct($clientOptions)
+    {
+        $this->primaryHost = $clientOptions->getPrimaryRestHost();
+        $this->fallbackHosts = $clientOptions->getFallbackHosts();
+        $this->hostCache = new HostCache($clientOptions->fallbackRetryTimeout);
+    }
+
+    public function fallbackHosts($currentHost) {
+        if ($currentHost != $this->primaryHost) {
+            yield $this->primaryHost;
+        }
+        $shuffledFallbacks = $this->fallbackHosts;
+        shuffle($shuffledFallbacks);
+        foreach ($shuffledFallbacks as $fallbackHost) {
+            if ($currentHost != $fallbackHost) {
+                yield $fallbackHost;
+            }
+        }
+    }
+
+    // getPreferredHost - Used to retrieve host in the order 1. Cached host 2. primary host
+    public function getPreferredHost() {
+        $host = $this->hostCache->get();
+        if (empty($host)) {
+            return $this->primaryHost;
+        }
+        return $host;
+    }
+
+    public function setPreferredHost($host) {
+        $this->hostCache->put($host);
+    }
+}
+

src/HostCache.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Ably;
+
+// TODO - Add SyncMutex support to the class to avoid data corruption due to concurrent READ/WRITE (e.g. Apache multithreading environment)
+use Ably\Utils\Miscellaneous;
+
+class HostCache
+{
+    private $timeoutDuration;
+    private $expireTime;
+    private $host = "";
+
+    public function __construct($timeoutDurationInMs)
+    {
+        $this->timeoutDuration = $timeoutDurationInMs;
+    }
+
+    public function put($host)
+    {
+        $this->host = $host;
+        $this->expireTime = Miscellaneous::systemTime() + $this->timeoutDuration;
+    }
+
+    public function get()
+    {
+        if (empty($this->host) || Miscellaneous::systemTime() > $this->expireTime) {
+            return "";
+        }
+        return $this->host;
+    }
+}