Modules

Kohana_Request_Client_Curl
extends Request_Client_External
extends Kohana_Request_Client_External
extends Request_Client
extends Kohana_Request_Client

Request_Client_External Curl driver performs external requests using the php-curl extention. This is the default driver for all external requests.

package
Kohana
category
Base
author
Kohana Team
copyright
© 2008-2012 Kohana Team
license
http://kohanaframework.org/license
uses
[PHP cURL](http://php.net/manual/en/book.curl.php)

Class declared in SYSPATH/classes/kohana/request/client/curl.php on line 13.

Properties

public static string $client

defines the external client to use by default

string(19) "Request_Client_Curl"

protected Cache $_cache

Caching library for request caching

protected array $_options

curl options

Methods

public _send_message( Request $request ) (defined in Kohana_Request_Client_Curl)

Sends the HTTP message Request to a remote server and processes the response.

Parameters

  • Request $request required - Request to send

Return Values

  • Response

Source Code

public function _send_message(Request $request)
{
	// Response headers
	$response_headers = array();

	$options = array();

	// Set the request method
	$options = $this->_set_curl_request_method($request, $options);

	// Set the request body. This is perfectly legal in CURL even
	// if using a request other than POST. PUT does support this method
	// and DOES NOT require writing data to disk before putting it, if
	// reading the PHP docs you may have got that impression. SdF
	$options[CURLOPT_POSTFIELDS] = $request->body();

	// Process headers
	if ($headers = $request->headers())
	{
		$http_headers = array();

		foreach ($headers as $key => $value)
		{
			$http_headers[] = $key.': '.$value;
		}

		$options[CURLOPT_HTTPHEADER] = $http_headers;
	}

	// Process cookies
	if ($cookies = $request->cookie())
	{
		$options[CURLOPT_COOKIE] = http_build_query($cookies, NULL, '; ');
	}

	// Create response
	$response = $request->create_response();
	$response_header = $response->headers();

	// Implement the standard parsing parameters
	$options[CURLOPT_HEADERFUNCTION]        = array($response_header, 'parse_header_string');
	$this->_options[CURLOPT_RETURNTRANSFER] = TRUE;
	$this->_options[CURLOPT_HEADER]         = FALSE;

	// Apply any additional options set to 
	$options += $this->_options;

	$uri = $request->uri();

	if ($query = $request->query())
	{
		$uri .= '?'.http_build_query($query, NULL, '&');
	}

	// Open a new remote connection
	$curl = curl_init($uri);

	// Set connection options
	if ( ! curl_setopt_array($curl, $options))
	{
		throw new Request_Exception('Failed to set CURL options, check CURL documentation: :url',
			array(':url' => 'http://php.net/curl_setopt_array'));
	}

	// Get the response body
	$body = curl_exec($curl);

	// Get the response information
	$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

	if ($body === FALSE)
	{
		$error = curl_error($curl);
	}

	// Close the connection
	curl_close($curl);

	if (isset($error))
	{
		throw new Request_Exception('Error fetching remote :url [ status :code ] :error',
			array(':url' => $request->url(), ':code' => $code, ':error' => $error));
	}

	$response->status($code)
		->body($body);

	return $response;
}

public _set_curl_request_method( Request $request , array $options ) (defined in Kohana_Request_Client_Curl)

Sets the appropriate curl request options. Uses the responding options for POST and PUT, uses CURLOPT_CUSTOMREQUEST otherwise

Parameters

  • Request $request required - $request
  • array $options required - $options

Return Values

  • array

Source Code

public function _set_curl_request_method(Request $request, array $options)
{
	switch ($request->method()) {
		case Request::POST:
			$options[CURLOPT_POST] = TRUE;
			break;
		case Request::PUT:
			$options[CURLOPT_PUT] = TRUE;
			break;
		default:
			$options[CURLOPT_CUSTOMREQUEST] = $request->method();
			break;
	}
	return $options;
}

public execute_request( Request $request ) (defined in Kohana_Request_Client_External)

Processes the request, executing the controller action that handles this request, determined by the Route.

  1. Before the controller action is called, the Controller::before method will be called.
  2. Next the controller action will be called.
  3. After the controller action is called, the Controller::after method will be called.

By default, the output from the controller is captured and returned, and no headers are sent.

$request->execute();

Parameters

  • Request $request required - A request object

Tags

Return Values

  • Response

Source Code

public function execute_request(Request $request)
{
	if (Kohana::$profiling)
	{
		// Set the benchmark name
		$benchmark = '"'.$request->uri().'"';

		if ($request !== Request::$initial AND Request::$current)
		{
			// Add the parent request uri
			$benchmark .= ' « "'.Request::$current->uri().'"';
		}

		// Start benchmarking
		$benchmark = Profiler::start('Requests', $benchmark);
	}

	// Store the current active request and replace current with new request
	$previous = Request::$current;
	Request::$current = $request;

	// Resolve the POST fields
	if ($post = $request->post())
	{
		$request->body(http_build_query($post, NULL, '&'))
			->headers('content-type', 'application/x-www-form-urlencoded');
	}

	// If Kohana expose, set the user-agent
	if (Kohana::$expose)
	{
		$request->headers('user-agent', 'Kohana Framework '.Kohana::VERSION.' ('.Kohana::CODENAME.')');
	}

	try
	{
		$response = $this->_send_message($request);
	}
	catch (Exception $e)
	{
		// Restore the previous request
		Request::$current = $previous;

		if (isset($benchmark))
		{
			// Delete the benchmark, it is invalid
			Profiler::delete($benchmark);
		}

		// Re-throw the exception
		throw $e;
	}

	// Restore the previous request
	Request::$current = $previous;

	if (isset($benchmark))
	{
		// Stop the benchmark
		Profiler::stop($benchmark);
	}

	// Return the response
	return $response;
}

public static factory( [ array $params = array(0) , string $client = NULL ] ) (defined in Kohana_Request_Client_External)

Factory method to create a new Request_Client_External object based on the client name passed, or defaulting to Request_Client_External::$client by default.

Request_Client_External::$client can be set in the application bootstrap.

Parameters

  • array $params = array(0) - Parameters to pass to the client
  • string $client = NULL - External client to use

Tags

Return Values

  • Request_Client_External

Source Code

public static function factory(array $params = array(), $client = NULL)
{
	if ($client === NULL)
	{
		$client = Request_Client_External::$client;
	}

	$client = new $client($params);

	if ( ! $client instanceof Request_Client_External)
	{
		throw new Request_Exception('Selected client is not a Request_Client_External object.');
	}

	return $client;
}

public options( [ mixed $key = NULL , mixed $value = NULL ] ) (defined in Kohana_Request_Client_External)

Set and get options for this request.

Parameters

  • mixed $key = NULL - Option name, or array of options
  • mixed $value = NULL - Option value

Return Values

  • mixed
  • Request_Client_External

Source Code

public function options($key = NULL, $value = NULL)
{
	if ($key === NULL)
		return $this->_options;

	if (is_array($key))
	{
		$this->_options = $key;
	}
	elseif ($value === NULL)
	{
		return Arr::get($this->_options, $key);
	}
	else
	{
		$this->_options[$key] = $value;
	}

	return $this;
}

public __construct( [ array $params = array(0) ] ) (defined in Kohana_Request_Client)

Creates a new Request_Client object, allows for dependency injection.

Parameters

  • array $params = array(0) - Params

Source Code

public function __construct(array $params = array())
{
	foreach ($params as $key => $value)
	{
		if (method_exists($this, $key))
		{
			$this->$key($value);
		}
	}
}

public cache( [ HTTP_Cache $cache = NULL ] ) (defined in Kohana_Request_Client)

Getter and setter for the internal caching engine, used to cache responses if available and valid.

Parameters

  • HTTP_Cache $cache = NULL - Engine to use for caching

Return Values

  • HTTP_Cache
  • Request_Client

Source Code

public function cache(HTTP_Cache $cache = NULL)
{
	if ($cache === NULL)
		return $this->_cache;

	$this->_cache = $cache;
	return $this;
}

public execute( Request $request ) (defined in Kohana_Request_Client)

Processes the request, executing the controller action that handles this request, determined by the Route.

  1. Before the controller action is called, the Controller::before method will be called.
  2. Next the controller action will be called.
  3. After the controller action is called, the Controller::after method will be called.

By default, the output from the controller is captured and returned, and no headers are sent.

$request->execute();

Parameters

  • Request $request required - $request

Tags

Return Values

  • Response

Source Code

public function execute(Request $request)
{
	if ($this->_cache instanceof HTTP_Cache)
		return $this->_cache->execute($this, $request);

	return $this->execute_request($request);
}