Merge pull request #1 from clue/socket-client

Update to use react/socket-client

Author: clue

.travis.yml

@@ -0,0 +1,8 @@
+language: php
+php:
+  - 5.4
+  - 5.3
+before_script:
+  - composer install --dev --prefer-source --no-interaction
+script:
+  - phpunit --coverage-text

ConnectionManager/Extra/ConnectionManagerDelay.php

@@ -2,30 +2,30 @@
 
 namespace ConnectionManager\Extra;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use React\EventLoop\LoopInterface;
 use React\Promise\Deferred;
 
-class ConnectionManagerDelay implements ConnectionManagerInterface
+class ConnectionManagerDelay implements ConnectorInterface
 {
     private $connectionManager;
     private $loop;
     private $delay;
 
-    public function __construct(ConnectionManagerInterface $connectionManager, LoopInterface $loop, $delay)
+    public function __construct(ConnectorInterface $connectionManager, LoopInterface $loop, $delay)
     {
         $this->connectionManager = $connectionManager;
         $this->loop = $loop;
         $this->delay = $delay;
     }
 
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         $deferred = new Deferred();
 
         $connectionManager = $this->connectionManager;
         $this->loop->addTimer($this->delay, function() use ($deferred, $connectionManager, $host, $port) {
-            $connectionManager->getConnect($host, $port)->then(
+            $connectionManager->create($host, $port)->then(
                 array($deferred, 'resolve'),
                 array($deferred, 'reject')
             );

ConnectionManager/Extra/ConnectionManagerReject.php

@@ -2,14 +2,14 @@
 
 namespace ConnectionManager\Extra;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use React\Promise\When;
 use \Exception;
 
 // a simple connection manager that rejects every single connection attempt
-class ConnectionManagerReject implements ConnectionManagerInterface
+class ConnectionManagerReject implements ConnectorInterface
 {
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         return When::reject(new Exception('Connection rejected'));
     }

ConnectionManager/Extra/ConnectionManagerRepeat.php

@@ -2,17 +2,17 @@
 
 namespace ConnectionManager\Extra;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use \InvalidArgumentException;
 use React\Promise\Deferred;
 use \Exception;
 
-class ConnectionManagerRepeat implements ConnectionManagerInterface
+class ConnectionManagerRepeat implements ConnectorInterface
 {
     protected $connectionManager;
     protected $maximumRepetitions;
 
-    public function __construct(ConnectionManagerInterface $connectionManager, $maximumRepetitons)
+    public function __construct(ConnectorInterface $connectionManager, $maximumRepetitons)
     {
         if ($maximumRepetitons < 1) {
             throw new InvalidArgumentException('Maximum number of repetitions must be >= 1');
@@ -21,15 +21,15 @@ public function __construct(ConnectionManagerInterface $connectionManager, $maxi
         $this->maximumRepetitions = $maximumRepetitons;
     }
 
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         return $this->tryConnection($this->maximumRepetitions, $host, $port);
     }
 
     public function tryConnection($repeat, $host, $port)
     {
         $that = $this;
-        return $this->connectionManager->getConnection($host, $port)->then(
+        return $this->connectionManager->create($host, $port)->then(
             null,
             function ($error) use ($repeat, $that) {
                 if ($repeat > 0) {

ConnectionManager/Extra/ConnectionManagerSwappable.php

@@ -2,24 +2,24 @@
 
 namespace ConnectionManager\Extra;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 
 // connection manager decorator which simplifies exchanging the actual connection manager during runtime
-class ConnectionManagerSwappable implements ConnectionManagerInterface
+class ConnectionManagerSwappable implements ConnectorInterface
 {
     protected $connectionManager;
 
-    public function __construct(ConnectionManagerInterface $connectionManager)
+    public function __construct(ConnectorInterface $connectionManager)
     {
         $this->connectionManager = $connectionManager;
     }
 
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
-        return $this->connectionManager->getConnection($host, $port);
+        return $this->connectionManager->create($host, $port);
     }
 
-    public function setConnectionManager(ConnectionManagerInterface $connectionManager)
+    public function setConnectionManager(ConnectorInterface $connectionManager)
     {
         $this->connectionManager = $connectionManager;
     }

ConnectionManager/Extra/ConnectionManagerTimeout.php

@@ -2,46 +2,47 @@
 
 namespace ConnectionManager\Extra;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use React\EventLoop\LoopInterface;
 use React\Promise\Deferred;
+use Exception;
 
-class ConnectionManagerTimeout implements ConnectionManagerInterface
+class ConnectionManagerTimeout implements ConnectorInterface
 {
     private $connectionManager;
     private $loop;
     private $timeout;
-    
-    public function __construct(ConnectionManagerInterface $connectionManager, LoopInterface $loop, $timeout)
+
+    public function __construct(ConnectorInterface $connectionManager, LoopInterface $loop, $timeout)
     {
         $this->connectionManager = $connectionManager;
         $this->loop = $loop;
         $this->timeout = $timeout;
     }
-    
-    public function getConnection($host, $port)
+
+    public function create($host, $port)
     {
         $deferred = new Deferred();
         $timedout = false;
-        
+
         $tid = $this->loop->addTimer($this->timeout, function() use ($deferred, &$timedout) {
             $deferred->reject(new Exception('Connection attempt timed out'));
             $timedout = true;
             // TODO: find a proper way to actually cancel the connection
         });
-        
+
         $loop = $this->loop;
-        $this->connectionManager->getConnection($host, $port)->then(function ($connection) use ($tid, $loop, &$timedout, $deferred) {
+        $this->connectionManager->create($host, $port)->then(function ($connection) use ($tid, $loop, &$timedout, $deferred) {
             if ($timedout) {
                 // connection successfully established but timeout already expired => close successful connection
                 $connection->end();
             } else {
-                $loop->removeTimeout($tid);
+                $loop->cancelTimer($tid);
                 $deferred->resolve($connection);
             }
-        }, function ($error) use ($loop, $tid) {
-            $loop->removeTimeout($tid);
-            throw $error;
+        }, function ($error) use ($loop, $tid, $deferred) {
+            $loop->cancelTimer($tid);
+            $deferred->reject($error);
         });
         return $deferred->promise();
     }

ConnectionManager/Extra/Multiple/ConnectionManagerConsecutive.php

@@ -2,27 +2,27 @@
 
 namespace ConnectionManager\Extra\Multiple;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use React\Promise\When;
 use \UnderflowException;
 
-class ConnectionManagerConsecutive implements ConnectionManagerInterface
+class ConnectionManagerConsecutive implements ConnectorInterface
 {
     protected $managers = array();
 
-    public function addConnectionManager(ConnectionManagerInterface $connectionManager)
+    public function addConnectionManager(ConnectorInterface $connectionManager)
     {
         $this->managers []= $connectionManager;
     }
 
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         return $this->tryConnection($this->managers, $host, $port);   
     }
 
     /**
      * 
-     * @param ConnectionManagerInterface[] $managers
+     * @param ConnectorInterface[] $managers
      * @param string $host
      * @param int $port
      * @return Promise
@@ -35,7 +35,7 @@ public function tryConnection(array $managers, $host, $port)
         }
         $manager = array_shift($managers);
         $that = $this;
-        return $manager->getConnection($host,$port)->then(null, function() use ($that, $managers, $host, $port) {
+        return $manager->create($host,$port)->then(null, function() use ($that, $managers, $host, $port) {
             // connection failed, re-try with remaining connection managers
             return $that->tryConnection($managers, $host, $port);
         });

ConnectionManager/Extra/Multiple/ConnectionManagerRandom.php

@@ -4,7 +4,7 @@
 
 class ConnectionManagerRandom extends ConnectionManagerConsecutive
 {
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         $managers = $this->managers;
         shuffle($managers);

ConnectionManager/Extra/Multiple/ConnectionManagerSelective.php

@@ -2,26 +2,26 @@
 
 namespace ConnectionManager\Extra\Multiple;
 
-use ConnectionManager\ConnectionManagerInterface;
+use React\SocketClient\ConnectorInterface;
 use React\Promise\When;
 use \UnderflowException;
 use \InvalidArgumentException;
 
-class ConnectionManagerSelective implements ConnectionManagerInterface
+class ConnectionManagerSelective implements ConnectorInterface
 {
     const MATCH_ALL = '*';
-    
+
     private $targets = array();
 
-    public function getConnection($host, $port)
+    public function create($host, $port)
     {
         try {
             $cm = $this->getConnectionManagerFor($host, $port);
         }
-        catch (Exception $e) {
+        catch (UnderflowException $e) {
             return When::reject($e);
         }
-        return $cm->getConnection($host, $port);
+        return $cm->create($host, $port);
     }
 
     public function addConnectionManagerFor($connectionManager, $targetHost=self::MATCH_ALL, $targetPort=self::MATCH_ALL, $priority=0)
@@ -34,27 +34,27 @@ public function addConnectionManagerFor($connectionManager, $targetHost=self::MA
             'port'      => $targetPort,
             'priority'  => $priority
         );
-        
+
         // return the key as new entry ID
         end($this->targets);
         $id = key($this->targets);
-        
+
         // sort array by priority
         $targets =& $this->targets;
         uksort($this->targets, function ($a, $b) use ($targets) {
             $pa = $targets[$a]['priority'];
             $pb = $targets[$b]['priority'];
             return ($pa < $pb ? -1 : ($pa > $pb ? 1 : ($a - $b)));
         });
-        
+
         return $id;
     }
-    
+
     public function getConnectionManagerEntries()
     {
         return $this->targets;
     }
-    
+
     public function removeConnectionManagerEntry($id)
     {
         unset($this->targets[$id]);

README.md

@@ -1,24 +1,24 @@
 # connection-manager-extra
 
 This project provides _extra_ (in terms of "additional", "extraordinary", "special" and "unusual") decorators
-built upon [connection-manager](https://github.com/clue/connection-manager).
+built upon [react/socket-client](https://github.com/reactphp/socket-client).
 
 ## Introduction
 
-If you're not already familar with [connection-manager](https://github.com/clue/connection-manager),
+If you're not already familar with [react/socket-client](https://github.com/reactphp/socket-client),
 think of it as an async (non-blocking) version of [`fsockopen()`](http://php.net/manual/en/function.fsockopen.php)
 or [`stream_socket_client()`](http://php.net/manual/en/function.stream-socket-client.php).
 I.e. before you can send and receive data to/from a remote server, you first have to establish a connection - which
 takes its time because it involves several steps.
-In order to be able to establish several connections at the same time, [connection-manager](https://github.com/clue/connection-manager) provides a simple
+In order to be able to establish several connections at the same time, [react/socket-client](https://github.com/reactphp/socket-client) provides a simple
 API to establish simple connections in an async (non-blocking) way.
 
-This project includes several classes that extend this base functionality by implementing the same simple `ConnectionManagerInterface`.
-This interface provides a single promise-based method `getConnection($host, $ip)` which can be used to easily notify
-when the connection is successfully established or the `ConnectionManager` gives up and the connection fails.
+This project includes several classes that extend this base functionality by implementing the same simple `ConnectorInterface`.
+This interface provides a single promise-based method `create($host, $ip)` which can be used to easily notify
+when the connection is successfully established or the `Connector` gives up and the connection fails.
 
 ```php
-$connectionManager->getConnection('www.google.com', 80)->then(function ($stream) {
+$connectionManager->create('www.google.com', 80)->then(function ($stream) {
     echo 'connection successfully established';
     $stream->write("GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
     $stream->end();
@@ -28,17 +28,17 @@ $connectionManager->getConnection('www.google.com', 80)->then(function ($stream)
 
 ```
 
-Because everything uses the same simple API, the resulting `ConnectionManager` classes can be easily interchanged
-and be used in places that expect the normal `ConnectionManagerInterface`. This can be used to stack them into each other,
+Because everything uses the same simple API, the resulting `Connector` classes can be easily interchanged
+and be used in places that expect the normal `ConnectorInterface`. This can be used to stack them into each other,
 like using [timeouts](#timeout) for TCP connections, [delaying](#delay) SSL/TLS connections,
-[retrying](#repeating--retrying) failed connection attemps, [randomly](#random) picking a `ConnectionManager` or
+[retrying](#repeating--retrying) failed connection attemps, [randomly](#random) picking a `Connector` or
 any combination thereof.
 
 ## Usage
 
 This section lists all this libraries' features along with some examples.
 The examples assume you've [installed](#install) this library and
-already [set up a `ConnectionManager` instance `$connectionManager`](https://github.com/clue/connection-manager#async-tcpip-connections).
+already [set up a `SocketClient/Connector` instance `$connectionManager`](https://github.com/reactphp/socket-client#async-tcpip-connections).
 
 All classes are located in the `ConnectionManager\Extra` namespace.
 
@@ -49,7 +49,7 @@ of `$repeat` times when the connection fails.
 
 ```php
 $connectionManagerRepeater = new \ConnectionManager\Extra\ConnectionManagerRepeat($connectionManager, 3);
-$connectionManagerRepeater->getConnection('www.google.com', 80)->then(function ($stream) {
+$connectionManagerRepeater->create('www.google.com', 80)->then(function ($stream) {
     echo 'connection successfully established';
     $stream->close();
 });
@@ -88,7 +88,7 @@ of using a fixed order, it always uses a randomly shuffled order.
 
 ### Selective
 
-The `ConnectionManagerSelective()` manages several `ConnectionManager`s and forwards connection through either of
+The `ConnectionManagerSelective()` manages several `Connector`s and forwards connection through either of
 those besed on lists similar to to firewall or networking access control lists (ACLs).
 
 This allows fine-grained control on how to handle outgoing connections, like rejecting advertisements,