Merge SocketClient component into this component

composer.json

@@ -1,19 +1,21 @@
 {
     "name": "react/socket",
-    "description": "Async, streaming plaintext TCP/IP and secure TLS socket server for React PHP",
-    "keywords": ["socket"],
+    "description": "Async, streaming plaintext TCP/IP and secure TLS socket server and client connections for ReactPHP",
+    "keywords": ["async", "socket", "stream", "connection", "ReactPHP"],
     "license": "MIT",
     "require": {
         "php": ">=5.3.0",
         "evenement/evenement": "~2.0|~1.0",
+        "react/dns": "0.4.*|0.3.*",
         "react/event-loop": "0.4.*|0.3.*",
         "react/stream": "^0.6 || ^0.5 || ^0.4.5",
-        "react/promise": "^2.0 || ^1.1"
+        "react/promise": "^2.1 || ^1.2",
+        "react/promise-timer": "~1.0"
     },
     "require-dev": {
-        "react/socket-client": "^0.6",
         "clue/block-react": "^1.1",
-        "phpunit/phpunit": "~4.8"
+        "phpunit/phpunit": "~4.8",
+        "react/stream": "^0.6"
     },
     "autoload": {
         "psr-4": {

examples/11-http.php

@@ -0,0 +1,25 @@
+<?php
+
+use React\EventLoop\Factory;
+use React\Socket\Connector;
+use React\Socket\ConnectionInterface;
+
+$target = isset($argv[1]) ? $argv[1] : 'www.google.com:80';
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$loop = Factory::create();
+$connector = new Connector($loop);
+
+$connector->connect($target)->then(function (ConnectionInterface $connection) use ($target) {
+    $connection->on('data', function ($data) {
+        echo $data;
+    });
+    $connection->on('close', function () {
+        echo '[CLOSED]' . PHP_EOL;
+    });
+
+    $connection->write("GET / HTTP/1.0\r\nHost: $target\r\n\r\n");
+}, 'printf');
+
+$loop->run();

examples/12-https.php

@@ -0,0 +1,25 @@
+<?php
+
+use React\EventLoop\Factory;
+use React\Socket\Connector;
+use React\Socket\ConnectionInterface;
+
+$target = isset($argv[1]) ? $argv[1] : 'www.google.com:443';
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$loop = Factory::create();
+$connector = new Connector($loop);
+
+$connector->connect('tls://' . $target)->then(function (ConnectionInterface $connection) use ($target) {
+    $connection->on('data', function ($data) {
+        echo $data;
+    });
+    $connection->on('close', function () {
+        echo '[CLOSED]' . PHP_EOL;
+    });
+
+    $connection->write("GET / HTTP/1.0\r\nHost: $target\r\n\r\n");
+}, 'printf');
+
+$loop->run();

examples/13-netcat.php

@@ -0,0 +1,50 @@
+<?php
+
+use React\EventLoop\Factory;
+use React\Socket\Connector;
+use React\Socket\ConnectionInterface;
+use React\Stream\ReadableResourceStream;
+use React\Stream\WritableResourceStream;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+if (!isset($argv[1])) {
+    fwrite(STDERR, 'Usage error: required argument <host:port>' . PHP_EOL);
+    exit(1);
+}
+
+$loop = Factory::create();
+$connector = new Connector($loop);
+
+$stdin = new ReadableResourceStream(STDIN, $loop);
+$stdin->pause();
+$stdout = new WritableResourceStream(STDOUT, $loop);
+$stderr = new WritableResourceStream(STDERR, $loop);
+
+$stderr->write('Connecting' . PHP_EOL);
+
+$connector->connect($argv[1])->then(function (ConnectionInterface $connection) use ($stdin, $stdout, $stderr) {
+    // pipe everything from STDIN into connection
+    $stdin->resume();
+    $stdin->pipe($connection);
+
+    // pipe everything from connection to STDOUT
+    $connection->pipe($stdout);
+
+    // report errors to STDERR
+    $connection->on('error', function ($error) use ($stderr) {
+        $stderr->write('Stream ERROR: ' . $error . PHP_EOL);
+    });
+
+    // report closing and stop reading from input
+    $connection->on('close', function () use ($stderr, $stdin) {
+        $stderr->write('[CLOSED]' . PHP_EOL);
+        $stdin->close();
+    });
+
+    $stderr->write('Connected' . PHP_EOL);
+}, function ($error) use ($stderr) {
+    $stderr->write('Connection ERROR: ' . $error . PHP_EOL);
+});
+
+$loop->run();

examples/14-web.php

@@ -0,0 +1,47 @@
+<?php
+
+use React\EventLoop\Factory;
+use React\Socket\ConnectionInterface;
+use React\Socket\Connector;
+use React\Stream\WritableResourceStream;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$uri = isset($argv[1]) ? $argv[1] : 'www.google.com';
+
+if (strpos($uri, '://') === false) {
+    $uri = 'http://' . $uri;
+}
+$parts = parse_url($uri);
+
+if (!$parts || !isset($parts['scheme'], $parts['host'])) {
+    fwrite(STDERR, 'Usage error: required argument <host:port>' . PHP_EOL);
+    exit(1);
+}
+
+$loop = Factory::create();
+$connector = new Connector($loop);
+
+if (!isset($parts['port'])) {
+    $parts['port'] = $parts['scheme'] === 'https' ? 443 : 80;
+}
+
+$host = $parts['host'];
+if (($parts['scheme'] === 'http' && $parts['port'] !== 80) || ($parts['scheme'] === 'https' && $parts['port'] !== 443)) {
+    $host .= ':' . $parts['port'];
+}
+$target = ($parts['scheme'] === 'https' ? 'tls' : 'tcp') . '://' . $parts['host'] . ':' . $parts['port'];
+$resource = isset($parts['path']) ? $parts['path'] : '/';
+if (isset($parts['query'])) {
+    $resource .= '?' . $parts['query'];
+}
+
+$stdout = new WritableResourceStream(STDOUT, $loop);
+
+$connector->connect($target)->then(function (ConnectionInterface $connection) use ($resource, $host, $stdout) {
+    $connection->pipe($stdout);
+
+    $connection->write("GET $resource HTTP/1.0\r\nHost: $host\r\n\r\n");
+}, 'printf');
+
+$loop->run();

src/ConnectionInterface.php

@@ -5,22 +5,22 @@
 use React\Stream\DuplexStreamInterface;
 
 /**
- * Any incoming connection is represented by this interface.
+ * Any incoming and outgoing connection is represented by this interface,
+ * such as a normal TCP/IP connection.
  *
- * An incoming connection is a duplex stream (both readable and writable) that
- * implements React's DuplexStreamInterface.
+ * An incoming or outgoing connection is a duplex stream (both readable and
+ * writable) that implements React's
+ * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface).
  * It contains additional properties for the local and remote address (client IP)
- * where this connection has been established from.
+ * where this connection has been established to/from.
  *
- * Note that this interface is only to be used to represent the server-side end
- * of an incoming connection.
- * It MUST NOT be used to represent an outgoing connection in a client-side
- * context.
- * If you want to establish an outgoing connection,
- * use React's SocketClient component instead.
+ * Most commonly, instances implementing this `ConnectionInterface` are emitted
+ * by all classes implementing the [`ServerInterface`](#serverinterface) and
+ * used by all classes implementing the [`ConnectorInterface`](#connectorinterface).
  *
  * Because the `ConnectionInterface` implements the underlying
- * `DuplexStreamInterface` you can use any of its events and methods as usual:
+ * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface)
+ * you can use any of its events and methods as usual:
  *
  * ```php
  * $connection->on('data', function ($chunk) {
@@ -49,15 +49,17 @@
  * [`DuplexStreamInterface`](https://github.com/reactphp/stream#duplexstreaminterface).
  *
  * @see DuplexStreamInterface
+ * @see ServerInterface
+ * @see ConnectorInterface
  */
 interface ConnectionInterface extends DuplexStreamInterface
 {
     /**
-     * Returns the remote address (client IP and port) where this connection has been established from
+     * Returns the remote address (client IP and port) where this connection has been established with
      *
      * ```php
      * $address = $connection->getRemoteAddress();
-     * echo 'Connection from ' . $address . PHP_EOL;
+     * echo 'Connection with ' . $address . PHP_EOL;
      * ```
      *
      * If the remote address can not be determined or is unknown at this time (such as
@@ -70,19 +72,19 @@ interface ConnectionInterface extends DuplexStreamInterface
      * ```php
      * $address = $connection->getRemoteAddress();
      * $ip = trim(parse_url('tcp://' . $address, PHP_URL_HOST), '[]');
-     * echo 'Connection from ' . $ip . PHP_EOL;
+     * echo 'Connection with ' . $ip . PHP_EOL;
      * ```
      *
      * @return ?string remote address (client IP and port) or null if unknown
      */
     public function getRemoteAddress();
 
     /**
-     * Returns the full local address (client IP and port) where this connection has been established to
+     * Returns the full local address (client IP and port) where this connection has been established with
      *
      * ```php
      * $address = $connection->getLocalAddress();
-     * echo 'Connection to ' . $address . PHP_EOL;
+     * echo 'Connection with ' . $address . PHP_EOL;
      * ```
      *
      * If the local address can not be determined or is unknown at this time (such as
@@ -97,6 +99,10 @@ public function getRemoteAddress();
      * the address `0.0.0.0`), you can use this method to find out which interface
      * actually accepted this connection (such as a public or local interface).
      *
+     * If your system has multiple interfaces (e.g. a WAN and a LAN interface),
+     * you can use this method to find out which interface was actually
+     * used for this connection.
+     *
      * @return ?string local address (client IP and port) or null if unknown
      * @see self::getRemoteAddress()
      */

src/Connector.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace React\Socket;
+
+use React\EventLoop\LoopInterface;
+use React\Dns\Resolver\Resolver;
+use React\Dns\Resolver\Factory;
+use React\Promise;
+use RuntimeException;
+
+/**
+ * The `Connector` class is the main class in this package that implements the
+ * `ConnectorInterface` and allows you to create streaming connections.
+ *
+ * You can use this connector to create any kind of streaming connections, such
+ * as plaintext TCP/IP, secure TLS or local Unix connection streams.
+ *
+ * Under the hood, the `Connector` is implemented as a *higher-level facade*
+ * or the lower-level connectors implemented in this package. This means it
+ * also shares all of their features and implementation details.
+ * If you want to typehint in your higher-level protocol implementation, you SHOULD
+ * use the generic [`ConnectorInterface`](#connectorinterface) instead.
+ *
+ * @see ConnectorInterface for the base interface
+ */
+final class Connector implements ConnectorInterface
+{
+    private $connectors = array();
+
+    public function __construct(LoopInterface $loop, array $options = array())
+    {
+        // apply default options if not explicitly given
+        $options += array(
+            'tcp' => true,
+            'tls' => true,
+            'unix' => true,
+
+            'dns' => true,
+            'timeout' => true,
+        );
+
+        if ($options['timeout'] === true) {
+            $options['timeout'] = (float)ini_get("default_socket_timeout");
+        }
+
+        if ($options['tcp'] instanceof ConnectorInterface) {
+            $tcp = $options['tcp'];
+        } else {
+            $tcp = new TcpConnector(
+                $loop,
+                is_array($options['tcp']) ? $options['tcp'] : array()
+            );
+        }
+
+        if ($options['dns'] !== false) {
+            if ($options['dns'] instanceof Resolver) {
+                $resolver = $options['dns'];
+            } else {
+                $factory = new Factory();
+                $resolver = $factory->create(
+                    $options['dns'] === true ? '8.8.8.8' : $options['dns'],
+                    $loop
+                );
+            }
+
+            $tcp = new DnsConnector($tcp, $resolver);
+        }
+
+        if ($options['tcp'] !== false) {
+            $options['tcp'] = $tcp;
+
+            if ($options['timeout'] !== false) {
+                $options['tcp'] = new TimeoutConnector(
+                    $options['tcp'],
+                    $options['timeout'],
+                    $loop
+                );
+            }
+
+            $this->connectors['tcp'] = $options['tcp'];
+        }
+
+        if ($options['tls'] !== false) {
+            if (!$options['tls'] instanceof ConnectorInterface) {
+                $options['tls'] = new SecureConnector(
+                    $tcp,
+                    $loop,
+                    is_array($options['tls']) ? $options['tls'] : array()
+                );
+            }
+
+            if ($options['timeout'] !== false) {
+                $options['tls'] = new TimeoutConnector(
+                    $options['tls'],
+                    $options['timeout'],
+                    $loop
+                );
+            }
+
+            $this->connectors['tls'] = $options['tls'];
+        }
+
+        if ($options['unix'] !== false) {
+            if (!$options['unix'] instanceof ConnectorInterface) {
+                $options['unix'] = new UnixConnector($loop);
+            }
+            $this->connectors['unix'] = $options['unix'];
+        }
+    }
+
+    public function connect($uri)
+    {
+        $scheme = 'tcp';
+        if (strpos($uri, '://') !== false) {
+            $scheme = (string)substr($uri, 0, strpos($uri, '://'));
+        }
+
+        if (!isset($this->connectors[$scheme])) {
+            return Promise\reject(new RuntimeException(
+                'No connector available for URI scheme "' . $scheme . '"'
+            ));
+        }
+
+        return $this->connectors[$scheme]->connect($uri);
+    }
+}
+