Merge pull request #25 from clue-labs/socket

clue · web-flow · commit 61790ceff038 · 2017-08-05T16:52:06.000+02:00
Replace legacy SocketClient with new Socket component and improve forward compatibility with new components
diff --git a/README.md b/README.md
@@ -40,7 +40,7 @@ $factory = new Factory($loop);
 ```
 
 If you need custom DNS, proxy or TLS settings, you can explicitly pass a
-custom instance of the [`ConnectorInterface`](https://github.com/reactphp/socket-client#connectorinterface):
+custom instance of the [`ConnectorInterface`](https://github.com/reactphp/socket#connectorinterface):
 
 ```php
 $factory = new Factory($loop, $connector);
diff --git a/composer.json b/composer.json
@@ -15,12 +15,11 @@
     },
     "require": {
     	"php": ">=5.3",
-        "react/event-loop": "~0.4.0|~0.3.0",
-        "react/socket-client": "^0.5 || ^0.4 || ^0.3",
-        "react/dns": "^0.4.1 || ^0.3",
+        "clue/qdatastream": "^0.6",
+        "react/event-loop": "^1.0 || ^0.5 || ^0.4 || ^0.3",
         "react/promise": "~2.0|~1.1",
-        "react/stream": "^0.4.2",
-        "clue/qdatastream": "^0.6"
+        "react/socket": "^1.0 || ^0.8 || ^0.7",
+        "react/stream": "^1.0 || ^0.7 || ^0.6 || ^0.5 || ^0.4.6"
     },
     "require-dev": {
         "clue/block-react": "^1.1",
diff --git a/examples/connect.php b/examples/connect.php
@@ -127,9 +127,9 @@
 
     $client->writeClientInit();
 
-    $client->on('close', function () use (&$timer) {
+    $client->on('close', function () use (&$timer, $loop) {
         var_dump('CLOSED');
-        $timer->cancel();
+        $loop->cancelTimer($timer);
     });
 
     $timer = $loop->addTimer(60.0 * 60, function ($timer) use ($client) {
diff --git a/src/Factory.php b/src/Factory.php
@@ -2,26 +2,22 @@
 
 namespace Clue\React\Quassel;
 
-use React\SocketClient\ConnectorInterface;
-use React\Stream\Stream;
-use Clue\React\Quassel\Io\Handshaker;
 use Clue\React\Quassel\Io\Prober;
-use React\EventLoop\LoopInterface;
-use React\Dns\Resolver\Factory as ResolverFactory;
-use React\SocketClient\Connector;
 use Clue\React\Quassel\Io\Protocol;
+use React\EventLoop\LoopInterface;
 use React\Promise;
+use React\Socket\ConnectorInterface;
+use React\Socket\Connector;
+use React\Stream\DuplexStreamInterface;
 use InvalidArgumentException;
 
 class Factory
 {
     public function __construct(LoopInterface $loop, ConnectorInterface $connector = null, Prober $prober = null)
     {
-    	if ($connector === null) {
-    		$resolverFactory = new ResolverFactory();
-    		$resolver = $resolverFactory->create('8.8.8.8', $loop);
-    		$connector = new Connector($loop, $resolver);
-    	}
+        if ($connector === null) {
+            $connector = new Connector($loop);
+        }
         if ($prober === null) {
             $prober = new Prober();
         }
@@ -53,14 +49,14 @@ public function createClient($address)
             }
         }
 
-        $promise = $this->connector->create($parts['host'], $parts['port']);
+        $promise = $this->connector->connect($parts['host'] . ':' . $parts['port']);
 
         // protocol probe not already set
         if ($probe === 0) {
             $connector = $this->connector;
             $prober = $this->prober;
 
-            $promise = $promise->then(function (Stream $stream) use ($prober, &$probe, $connector, $parts) {
+            $promise = $promise->then(function (DuplexStreamInterface $stream) use ($prober, &$probe, $connector, $parts) {
                 return $prober->probe($stream)->then(
                     function ($ret) use (&$probe, $stream) {
                         // probe returned successfully, create new client for this stream
@@ -73,7 +69,7 @@ function ($e) use ($connector, $parts) {
                         if ($e->getCode() === Prober::ERROR_CLOSED) {
                             // legacy servers will terminate connection while probing
                             // let's just open a new connection and assume default probe
-                            return $connector->create($parts['host'], $parts['port']);
+                            return $connector->connect($parts['host'] . ':' . $parts['port']);
                         }
                         throw $e;
                     }
@@ -82,7 +78,7 @@ function ($e) use ($connector, $parts) {
         }
 
         return $promise->then(
-            function (Stream $stream) use (&$probe) {
+            function (DuplexStreamInterface $stream) use (&$probe) {
                 return new Client($stream, Protocol::createFromProbe($probe));
             }
         );
diff --git a/src/Io/Prober.php b/src/Io/Prober.php
@@ -2,7 +2,7 @@
 
 namespace Clue\React\Quassel\Io;
 
-use React\Stream\Stream;
+use React\Stream\DuplexStreamInterface;
 use React\Promise\Deferred;
 
 class Prober
@@ -20,7 +20,7 @@ public function __construct(Binary $binary = null)
         $this->binary = $binary;
     }
 
-    public function probe(Stream $stream, $compression = false, $encryption = false)
+    public function probe(DuplexStreamInterface $stream, $compression = false, $encryption = false)
     {
         $magic = Protocol::MAGIC;
         if ($compression) {
diff --git a/tests/ClientTest.php b/tests/ClientTest.php
@@ -4,12 +4,13 @@
 use Clue\React\Quassel\Io\Protocol;
 use Clue\QDataStream\QVariant;
 use Clue\QDataStream\Types;
+use React\Stream\ThroughStream;
 
 class ClientTest extends TestCase
 {
     public function setUp()
     {
-        $this->stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->setMethods(array('write', 'end', 'close', 'pause', 'resume', 'isReadable', 'isWritable'))->getMock();
+        $this->stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();
         $this->protocol = $this->getMockBuilder('Clue\React\Quassel\Io\Protocol')->disableOriginalConstructor()->getMock();
         $this->splitter = $this->getMockBuilder('Clue\React\Quassel\Io\PacketSplitter')->disableOriginalConstructor()->getMock();
 
@@ -61,34 +62,49 @@ public function testPipeWillReturnDestStream()
 
     public function testCloseEventWillBeForwarded()
     {
+        $this->stream = new ThroughStream();
+        $this->client = new Client($this->stream, $this->protocol, $this->splitter);
+
         $this->client->on('close', $this->expectCallableOnce());
         $this->stream->emit('close');
     }
 
     public function testDrainEventWillBeForwarded()
     {
+        $this->stream = new ThroughStream();
+        $this->client = new Client($this->stream, $this->protocol, $this->splitter);
+
         $this->client->on('drain', $this->expectCallableOnce());
         $this->stream->emit('drain');
     }
 
     public function testEndEventWillBeForwardedAndClose()
     {
+        $this->stream = new ThroughStream();
+        $this->client = new Client($this->stream, $this->protocol, $this->splitter);
+
         $this->client->on('end', $this->expectCallableOnce());
-        $this->stream->expects($this->once())->method('close');
-        $this->stream->emit('end');
+        $this->stream->on('close', $this->expectCallableOnce());
+        $this->stream->end();
     }
 
     public function testErrorEventWillBeForwardedAndClose()
     {
+        $this->stream = new ThroughStream();
+        $this->client = new Client($this->stream, $this->protocol, $this->splitter);
+
         $e = new \RuntimeException();
 
         $this->client->on('error', $this->expectCallableOnceWith($e));
-        $this->stream->expects($this->once())->method('close');
+        $this->stream->on('close', $this->expectCallableOnce());
         $this->stream->emit('error', array($e));
     }
 
     public function testDataEventWillNotBeForwardedIfItIsAnIncompletePacket()
     {
+        $this->stream = new ThroughStream();
+        $this->client = new Client($this->stream, $this->protocol, $this->splitter);
+
         $this->splitter->expects($this->once())->method('push')->with("hello", array($this->client, 'handlePacket'));
         $this->client->on('data', $this->expectCallableNever());
 
diff --git a/tests/FactoryTest.php b/tests/FactoryTest.php
@@ -10,7 +10,7 @@ class FactoryTest extends TestCase
     public function setUp()
     {
         $this->loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock();
-        $this->connector = $this->getMockBuilder('React\SocketClient\ConnectorInterface')->getMock();
+        $this->connector = $this->getMockBuilder('React\Socket\ConnectorInterface')->getMock();
         $this->prober = $this->getMockBuilder('Clue\React\Quassel\Io\Prober')->disableOriginalConstructor()->getMock();
 
         $this->factory = new Factory($this->loop, $this->connector, $this->prober);
@@ -24,46 +24,46 @@ public function testCtorOptionalArgs()
     public function testPassHostnameAndDefaultPortToConnector()
     {
         $deferred = new Deferred();
-        $this->connector->expects($this->once())->method('create')->with($this->equalTo('example.com', 4242))->will($this->returnValue($deferred->promise()));
+        $this->connector->expects($this->once())->method('connect')->with($this->equalTo('example.com:4242'))->will($this->returnValue($deferred->promise()));
         $this->factory->createClient('example.com');
     }
 
     public function testPassHostnameAndPortToConnector()
     {
         $deferred = new Deferred();
-        $this->connector->expects($this->once())->method('create')->with($this->equalTo('example.com', 1234))->will($this->returnValue($deferred->promise()));
+        $this->connector->expects($this->once())->method('connect')->with($this->equalTo('example.com:1234'))->will($this->returnValue($deferred->promise()));
         $this->factory->createClient('example.com:1234');
     }
 
     public function testInvalidUriWillRejectWithoutConnecting()
     {
-        $this->connector->expects($this->never())->method('create');
+        $this->connector->expects($this->never())->method('connect');
 
         $this->expectPromiseReject($this->factory->createClient('///'));
     }
 
     public function testInvalidSchemeWillRejectWithoutConnecting()
     {
-        $this->connector->expects($this->never())->method('create');
+        $this->connector->expects($this->never())->method('connect');
 
         $this->expectPromiseReject($this->factory->createClient('https://example.com:1234/'));
     }
 
     public function testWillInvokeProberAfterConnecting()
     {
-        $stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->getMock();
+        $stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();
 
-        $this->connector->expects($this->once())->method('create')->will($this->returnValue(Promise\resolve($stream)));
+        $this->connector->expects($this->once())->method('connect')->will($this->returnValue(Promise\resolve($stream)));
         $this->prober->expects($this->once())->method('probe')->with($this->equalTo($stream))->will($this->returnValue(Promise\resolve(Protocol::TYPE_DATASTREAM)));
 
         $this->expectPromiseResolve($this->factory->createClient('localhost'));
     }
 
     public function testWillNotInvokeProberIfSchemeIsProtocol()
     {
-        $stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->getMock();
+        $stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();
 
-        $this->connector->expects($this->once())->method('create')->will($this->returnValue(Promise\resolve($stream)));
+        $this->connector->expects($this->once())->method('connect')->will($this->returnValue(Promise\resolve($stream)));
         $this->prober->expects($this->never())->method('probe');
 
         $this->expectPromiseResolve($this->factory->createClient('legacy://localhost'));

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace Clue\React\Quassel\Io;`
`4`	`4`
`5`		`-use React\Stream\Stream;`
	`5`	`+use React\Stream\DuplexStreamInterface;`
`6`	`6`	`use React\Promise\Deferred;`
`7`	`7`
`8`	`8`	`class Prober`
`@@ -20,7 +20,7 @@ public function __construct(Binary $binary = null)`
`20`	`20`	`$this->binary = $binary;`
`21`	`21`	`}`
`22`	`22`
`23`		`- public function probe(Stream $stream, $compression = false, $encryption = false)`
	`23`	`+ public function probe(DuplexStreamInterface $stream, $compression = false, $encryption = false)`
`24`	`24`	`{`
`25`	`25`	`$magic = Protocol::MAGIC;`
`26`	`26`	`if ($compression) {`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,13 @@`
`4`	`4`	`use Clue\React\Quassel\Io\Protocol;`
`5`	`5`	`use Clue\QDataStream\QVariant;`
`6`	`6`	`use Clue\QDataStream\Types;`
	`7`	`+use React\Stream\ThroughStream;`
`7`	`8`
`8`	`9`	`class ClientTest extends TestCase`
`9`	`10`	`{`
`10`	`11`	`public function setUp()`
`11`	`12`	`{`
`12`		`- $this->stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->setMethods(array('write', 'end', 'close', 'pause', 'resume', 'isReadable', 'isWritable'))->getMock();`
	`13`	`+ $this->stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();`
`13`	`14`	`$this->protocol = $this->getMockBuilder('Clue\React\Quassel\Io\Protocol')->disableOriginalConstructor()->getMock();`
`14`	`15`	`$this->splitter = $this->getMockBuilder('Clue\React\Quassel\Io\PacketSplitter')->disableOriginalConstructor()->getMock();`
`15`	`16`
`@@ -61,34 +62,49 @@ public function testPipeWillReturnDestStream()`
`61`	`62`
`62`	`63`	`public function testCloseEventWillBeForwarded()`
`63`	`64`	`{`
	`65`	`+ $this->stream = new ThroughStream();`
	`66`	`+ $this->client = new Client($this->stream, $this->protocol, $this->splitter);`
	`67`	`+`
`64`	`68`	`$this->client->on('close', $this->expectCallableOnce());`
`65`	`69`	`$this->stream->emit('close');`
`66`	`70`	`}`
`67`	`71`
`68`	`72`	`public function testDrainEventWillBeForwarded()`
`69`	`73`	`{`
	`74`	`+ $this->stream = new ThroughStream();`
	`75`	`+ $this->client = new Client($this->stream, $this->protocol, $this->splitter);`
	`76`	`+`
`70`	`77`	`$this->client->on('drain', $this->expectCallableOnce());`
`71`	`78`	`$this->stream->emit('drain');`
`72`	`79`	`}`
`73`	`80`
`74`	`81`	`public function testEndEventWillBeForwardedAndClose()`
`75`	`82`	`{`
	`83`	`+ $this->stream = new ThroughStream();`
	`84`	`+ $this->client = new Client($this->stream, $this->protocol, $this->splitter);`
	`85`	`+`
`76`	`86`	`$this->client->on('end', $this->expectCallableOnce());`
`77`		`- $this->stream->expects($this->once())->method('close');`
`78`		`- $this->stream->emit('end');`
	`87`	`+ $this->stream->on('close', $this->expectCallableOnce());`
	`88`	`+ $this->stream->end();`
`79`	`89`	`}`
`80`	`90`
`81`	`91`	`public function testErrorEventWillBeForwardedAndClose()`
`82`	`92`	`{`
	`93`	`+ $this->stream = new ThroughStream();`
	`94`	`+ $this->client = new Client($this->stream, $this->protocol, $this->splitter);`
	`95`	`+`
`83`	`96`	`$e = new \RuntimeException();`
`84`	`97`
`85`	`98`	`$this->client->on('error', $this->expectCallableOnceWith($e));`
`86`		`- $this->stream->expects($this->once())->method('close');`
	`99`	`+ $this->stream->on('close', $this->expectCallableOnce());`
`87`	`100`	`$this->stream->emit('error', array($e));`
`88`	`101`	`}`
`89`	`102`
`90`	`103`	`public function testDataEventWillNotBeForwardedIfItIsAnIncompletePacket()`
`91`	`104`	`{`
	`105`	`+ $this->stream = new ThroughStream();`
	`106`	`+ $this->client = new Client($this->stream, $this->protocol, $this->splitter);`
	`107`	`+`
`92`	`108`	`$this->splitter->expects($this->once())->method('push')->with("hello", array($this->client, 'handlePacket'));`
`93`	`109`	`$this->client->on('data', $this->expectCallableNever());`
`94`	`110`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ class FactoryTest extends TestCase`
`10`	`10`	`public function setUp()`
`11`	`11`	`{`
`12`	`12`	`$this->loop = $this->getMockBuilder('React\EventLoop\LoopInterface')->getMock();`
`13`		`- $this->connector = $this->getMockBuilder('React\SocketClient\ConnectorInterface')->getMock();`
	`13`	`+ $this->connector = $this->getMockBuilder('React\Socket\ConnectorInterface')->getMock();`
`14`	`14`	`$this->prober = $this->getMockBuilder('Clue\React\Quassel\Io\Prober')->disableOriginalConstructor()->getMock();`
`15`	`15`
`16`	`16`	`$this->factory = new Factory($this->loop, $this->connector, $this->prober);`
`@@ -24,46 +24,46 @@ public function testCtorOptionalArgs()`
`24`	`24`	`public function testPassHostnameAndDefaultPortToConnector()`
`25`	`25`	`{`
`26`	`26`	`$deferred = new Deferred();`
`27`		`- $this->connector->expects($this->once())->method('create')->with($this->equalTo('example.com', 4242))->will($this->returnValue($deferred->promise()));`
	`27`	`+ $this->connector->expects($this->once())->method('connect')->with($this->equalTo('example.com:4242'))->will($this->returnValue($deferred->promise()));`
`28`	`28`	`$this->factory->createClient('example.com');`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public function testPassHostnameAndPortToConnector()`
`32`	`32`	`{`
`33`	`33`	`$deferred = new Deferred();`
`34`		`- $this->connector->expects($this->once())->method('create')->with($this->equalTo('example.com', 1234))->will($this->returnValue($deferred->promise()));`
	`34`	`+ $this->connector->expects($this->once())->method('connect')->with($this->equalTo('example.com:1234'))->will($this->returnValue($deferred->promise()));`
`35`	`35`	`$this->factory->createClient('example.com:1234');`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public function testInvalidUriWillRejectWithoutConnecting()`
`39`	`39`	`{`
`40`		`- $this->connector->expects($this->never())->method('create');`
	`40`	`+ $this->connector->expects($this->never())->method('connect');`
`41`	`41`
`42`	`42`	`$this->expectPromiseReject($this->factory->createClient('///'));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`public function testInvalidSchemeWillRejectWithoutConnecting()`
`46`	`46`	`{`
`47`		`- $this->connector->expects($this->never())->method('create');`
	`47`	`+ $this->connector->expects($this->never())->method('connect');`
`48`	`48`
`49`	`49`	`$this->expectPromiseReject($this->factory->createClient('https://example.com:1234/'));`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`public function testWillInvokeProberAfterConnecting()`
`53`	`53`	`{`
`54`		`- $stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->getMock();`
	`54`	`+ $stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();`
`55`	`55`
`56`		`- $this->connector->expects($this->once())->method('create')->will($this->returnValue(Promise\resolve($stream)));`
	`56`	`+ $this->connector->expects($this->once())->method('connect')->will($this->returnValue(Promise\resolve($stream)));`
`57`	`57`	`$this->prober->expects($this->once())->method('probe')->with($this->equalTo($stream))->will($this->returnValue(Promise\resolve(Protocol::TYPE_DATASTREAM)));`
`58`	`58`
`59`	`59`	`$this->expectPromiseResolve($this->factory->createClient('localhost'));`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`public function testWillNotInvokeProberIfSchemeIsProtocol()`
`63`	`63`	`{`
`64`		`- $stream = $this->getMockBuilder('React\Stream\Stream')->disableOriginalConstructor()->getMock();`
	`64`	`+ $stream = $this->getMockBuilder('React\Stream\DuplexStreamInterface')->getMock();`
`65`	`65`
`66`		`- $this->connector->expects($this->once())->method('create')->will($this->returnValue(Promise\resolve($stream)));`
	`66`	`+ $this->connector->expects($this->once())->method('connect')->will($this->returnValue(Promise\resolve($stream)));`
`67`	`67`	`$this->prober->expects($this->never())->method('probe');`
`68`	`68`
`69`	`69`	`$this->expectPromiseResolve($this->factory->createClient('legacy://localhost'));`