lithium\net\http\Service

class

Basic Http Service.

Source

class Service extends \lithium\core\ObjectDeprecated {

	/**
	 * The `Socket` instance used to send `Service` calls.
	 *
	 * @var lithium\net\Socket
	 */
	public $connection = null;

	/**
	 * Holds the last request and response object
	 *
	 * @var object
	 */
	public $last = null;

	/**
	 * Auto config
	 *
	 * @var array
	 */
	protected $_autoConfig = ['classes' => 'merge', 'responseTypes'];

	/**
	 * Array of closures that return various pieces of information about an HTTP response.
	 *
	 * @var array
	 */
	protected $_responseTypes = [];

	/**
	 * Indicates whether `Service` can connect to the HTTP endpoint for which it is configured.
	 * Defaults to true until a connection attempt fails.
	 *
	 * @var boolean
	 */
	protected $_isConnected = false;

	/**
	 * Fully-name-spaced class references to `Service` class dependencies.
	 *
	 * @var array
	 */
	protected $_classes = [
		'media'    => 'lithium\net\http\Media',
		'request'  => 'lithium\net\http\Request',
		'response' => 'lithium\net\http\Response'
	];

	/**
	 * Constructor. Initializes a new `Service` instance with the default HTTP request settings
	 * and transport- and format-handling classes.
	 *
	 * @param array $config Available configuration options are:
	 *        - `'persistent'` _boolean_
	 *        - `'scheme'` _string_
	 *        - `'host'` _string_
	 *        - `'port'` _integer_
	 *        - `'timeout'` _integer_
	 *        - `'auth'` _boolean_
	 *        - `'username'` _string_
	 *        - `'password'` _string_
	 *        - `'encoding'` _string_
	 *        - `'socket'` _string_
	 * @return void
	 */
	public function __construct(array $config = []) {
		$defaults = [
			'persistent' => false,
			'scheme'     => 'http',
			'host'       => 'localhost',
			'port'       => null,
			'timeout'    => 30,
			'auth'       => null,
			'username'   => null,
			'password'   => null,
			'encoding'   => 'UTF-8',
			'socket'     => 'Context'
		];
		parent::__construct($config + $defaults);
	}

	/**
	 * Initialize connection.
	 *
	 * @return void
	 */
	protected function _init() {
		$config = ['classes' => $this->_classes] + $this->_config;

		try {
			$this->connection = Libraries::instance('socket', $config['socket'], $config);
		} catch(ClassNotFoundException $e) {
			$this->connection = null;
		}
		$this->_responseTypes += [
			'headers' => function($response) { return $response->headers; },
			'body' => function($response) { return $response->body(); },
			'code' => function($response) { return $response->status['code']; }
		];
	}

	/**
	 * Magic method to handle other HTTP methods.
	 *
	 * @param string $method
	 * @param string $params
	 * @return mixed
	 */
	public function __call($method, $params = []) {
		array_unshift($params, $method);
		return call_user_func_array(array($this, 'send'), $params);
	}

	/**
	 * Determines if a given method can be called.
	 *
	 * @deprecated
	 * @param string $method Name of the method.
	 * @param boolean $internal Provide `true` to perform check from inside the
	 *                class/object. When `false` checks also for public visibility;
	 *                defaults to `false`.
	 * @return boolean Returns `true` if the method can be called, `false` otherwise.
	 */
	public function respondsTo($method, $internal = false) {
		$message  = '`' . __METHOD__ . '()` has been deprecated. ';
		$message .= "Use `is_callable([<class>, '<method>'])` instead.";
		trigger_error($message, E_USER_DEPRECATED);

		return is_callable([$this, $method], true);
	}

	/**
	 * Send HEAD request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function head($path = null, $data = [], array $options = []) {
		$defaults = ['return' => 'headers', 'type' => false];
		return $this->send(__FUNCTION__, $path, $data, $options + $defaults);
	}

	/**
	 * Send GET request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function get($path = null, $data = [], array $options = []) {
		$defaults = ['type' => false];
		return $this->send(__FUNCTION__, $path, $data, $options + $defaults);
	}

	/**
	 * Send POST request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function post($path = null, $data = [], array $options = []) {
		return $this->send(__FUNCTION__, $path, $data, $options);
	}

	/**
	 * Send PUT request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function put($path = null, $data = [], array $options = []) {
		return $this->send(__FUNCTION__, $path, $data, $options);
	}

	/**
	 * Send PATCH request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function patch($path = null, $data = [], array $options = []) {
		return $this->send(__FUNCTION__, $path, $data, $options);
	}

	/**
	 * Send DELETE request.
	 *
	 * @param string $path
	 * @param array $data
	 * @param array $options
	 * @return string
	 */
	public function delete($path = null, $data = [], array $options = []) {
		$defaults = ['type' => false];
		return $this->send(__FUNCTION__, $path, $data, $options + $defaults);
	}

	/**
	 * Send request and return response data. Will open the connection if
	 * needed and always close it after sending the request.
	 *
	 * Will automatically authenticate when receiving a `401` HTTP status code
	 * then continue retrying sending initial request.
	 *
	 * @param string $method
	 * @param string $path
	 * @param array $data the parameters for the request. For GET/DELETE this is the query string
	 *        for POST/PUT this is the body
	 * @param array $options passed to request and socket
	 * @return string
	 */
	public function send($method, $path = null, $data = [], array $options = []) {
		$defaults = ['return' => 'body'];
		$options += $defaults;
		$request = $this->_request($method, $path, $data, $options);
		$options += ['message' => $request];

		if (!$this->connection || !$this->connection->open($options)) {
			return;
		}
		$response = $this->connection->send($request, $options);
		$this->connection->close();

		if ($response->status['code'] == 401 && ($auth = $response->digest())) {
			$request->auth = $auth;
			$this->connection->open(['message' => $request] + $options);
			$response = $this->connection->send($request, $options);
			$this->connection->close();
		}
		$this->last = (object) compact('request', 'response');

		$handlers = $this->_responseTypes;
		$handler = isset($handlers[$options['return']]) ? $handlers[$options['return']] : null;

		return $handler ? $handler($response) : $response;
	}

	/**
	 * Instantiates a request object (usually an instance of `http\Request`) and tests its
	 * properties based on the request type and data to be sent.
	 *
	 * @param string $method The HTTP method of the request, i.e. `'GET'`, `'HEAD'`, `'OPTIONS'`,
	 *        etc. Can be passed in upper- or lower-case.
	 * @param string $path The
	 * @param string $data
	 * @param string $options
	 * @return object Returns an instance of `http\Request`, configured with an HTTP method, query
	 *         string or POST/PUT/PATCH data, and URL.
	 */
	protected function _request($method, $path, $data, $options) {
		$defaults = ['type' => 'form'];
		$options += $defaults + $this->_config;

		$request = Libraries::instance(null, 'request', $options, $this->_classes);
		$request->path = str_replace('//', '/', "{$request->path}{$path}");
		$request->method = $method = strtoupper($method);
		$hasBody = in_array($method, ['POST', 'PUT', 'PATCH']);
		$hasBody ? $request->body($data) : $request->query = $data;
		return $request;
	}
}