forked from lino/radar-wp
Initial import.
This commit is contained in:
commit
86383280c9
428 changed files with 68738 additions and 0 deletions
968
vendor/guzzle/http/Guzzle/Http/Message/Response.php
vendored
Normal file
968
vendor/guzzle/http/Guzzle/Http/Message/Response.php
vendored
Normal file
|
@ -0,0 +1,968 @@
|
|||
<?php
|
||||
|
||||
namespace Guzzle\Http\Message;
|
||||
|
||||
use Guzzle\Common\Version;
|
||||
use Guzzle\Common\ToArrayInterface;
|
||||
use Guzzle\Common\Exception\RuntimeException;
|
||||
use Guzzle\Http\EntityBodyInterface;
|
||||
use Guzzle\Http\EntityBody;
|
||||
use Guzzle\Http\Exception\BadResponseException;
|
||||
use Guzzle\Http\RedirectPlugin;
|
||||
use Guzzle\Parser\ParserRegistry;
|
||||
|
||||
/**
|
||||
* Guzzle HTTP response object
|
||||
*/
|
||||
class Response extends AbstractMessage implements \Serializable
|
||||
{
|
||||
/**
|
||||
* @var array Array of reason phrases and their corresponding status codes
|
||||
*/
|
||||
private static $statusTexts = array(
|
||||
100 => 'Continue',
|
||||
101 => 'Switching Protocols',
|
||||
102 => 'Processing',
|
||||
200 => 'OK',
|
||||
201 => 'Created',
|
||||
202 => 'Accepted',
|
||||
203 => 'Non-Authoritative Information',
|
||||
204 => 'No Content',
|
||||
205 => 'Reset Content',
|
||||
206 => 'Partial Content',
|
||||
207 => 'Multi-Status',
|
||||
208 => 'Already Reported',
|
||||
226 => 'IM Used',
|
||||
300 => 'Multiple Choices',
|
||||
301 => 'Moved Permanently',
|
||||
302 => 'Found',
|
||||
303 => 'See Other',
|
||||
304 => 'Not Modified',
|
||||
305 => 'Use Proxy',
|
||||
307 => 'Temporary Redirect',
|
||||
308 => 'Permanent Redirect',
|
||||
400 => 'Bad Request',
|
||||
401 => 'Unauthorized',
|
||||
402 => 'Payment Required',
|
||||
403 => 'Forbidden',
|
||||
404 => 'Not Found',
|
||||
405 => 'Method Not Allowed',
|
||||
406 => 'Not Acceptable',
|
||||
407 => 'Proxy Authentication Required',
|
||||
408 => 'Request Timeout',
|
||||
409 => 'Conflict',
|
||||
410 => 'Gone',
|
||||
411 => 'Length Required',
|
||||
412 => 'Precondition Failed',
|
||||
413 => 'Request Entity Too Large',
|
||||
414 => 'Request-URI Too Long',
|
||||
415 => 'Unsupported Media Type',
|
||||
416 => 'Requested Range Not Satisfiable',
|
||||
417 => 'Expectation Failed',
|
||||
422 => 'Unprocessable Entity',
|
||||
423 => 'Locked',
|
||||
424 => 'Failed Dependency',
|
||||
425 => 'Reserved for WebDAV advanced collections expired proposal',
|
||||
426 => 'Upgrade required',
|
||||
428 => 'Precondition Required',
|
||||
429 => 'Too Many Requests',
|
||||
431 => 'Request Header Fields Too Large',
|
||||
500 => 'Internal Server Error',
|
||||
501 => 'Not Implemented',
|
||||
502 => 'Bad Gateway',
|
||||
503 => 'Service Unavailable',
|
||||
504 => 'Gateway Timeout',
|
||||
505 => 'HTTP Version Not Supported',
|
||||
506 => 'Variant Also Negotiates (Experimental)',
|
||||
507 => 'Insufficient Storage',
|
||||
508 => 'Loop Detected',
|
||||
510 => 'Not Extended',
|
||||
511 => 'Network Authentication Required',
|
||||
);
|
||||
|
||||
/** @var EntityBodyInterface The response body */
|
||||
protected $body;
|
||||
|
||||
/** @var string The reason phrase of the response (human readable code) */
|
||||
protected $reasonPhrase;
|
||||
|
||||
/** @var string The status code of the response */
|
||||
protected $statusCode;
|
||||
|
||||
/** @var array Information about the request */
|
||||
protected $info = array();
|
||||
|
||||
/** @var string The effective URL that returned this response */
|
||||
protected $effectiveUrl;
|
||||
|
||||
/** @var array Cacheable response codes (see RFC 2616:13.4) */
|
||||
protected static $cacheResponseCodes = array(200, 203, 206, 300, 301, 410);
|
||||
|
||||
/**
|
||||
* Create a new Response based on a raw response message
|
||||
*
|
||||
* @param string $message Response message
|
||||
*
|
||||
* @return self|bool Returns false on error
|
||||
*/
|
||||
public static function fromMessage($message)
|
||||
{
|
||||
$data = ParserRegistry::getInstance()->getParser('message')->parseResponse($message);
|
||||
if (!$data) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$response = new static($data['code'], $data['headers'], $data['body']);
|
||||
$response->setProtocol($data['protocol'], $data['version'])
|
||||
->setStatus($data['code'], $data['reason_phrase']);
|
||||
|
||||
// Set the appropriate Content-Length if the one set is inaccurate (e.g. setting to X)
|
||||
$contentLength = (string) $response->getHeader('Content-Length');
|
||||
$actualLength = strlen($data['body']);
|
||||
if (strlen($data['body']) > 0 && $contentLength != $actualLength) {
|
||||
$response->setHeader('Content-Length', $actualLength);
|
||||
}
|
||||
|
||||
return $response;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct the response
|
||||
*
|
||||
* @param string $statusCode The response status code (e.g. 200, 404, etc)
|
||||
* @param ToArrayInterface|array $headers The response headers
|
||||
* @param string|resource|EntityBodyInterface $body The body of the response
|
||||
*
|
||||
* @throws BadResponseException if an invalid response code is given
|
||||
*/
|
||||
public function __construct($statusCode, $headers = null, $body = null)
|
||||
{
|
||||
parent::__construct();
|
||||
$this->setStatus($statusCode);
|
||||
$this->body = EntityBody::factory($body !== null ? $body : '');
|
||||
|
||||
if ($headers) {
|
||||
if (is_array($headers)) {
|
||||
$this->setHeaders($headers);
|
||||
} elseif ($headers instanceof ToArrayInterface) {
|
||||
$this->setHeaders($headers->toArray());
|
||||
} else {
|
||||
throw new BadResponseException('Invalid headers argument received');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
return $this->getMessage();
|
||||
}
|
||||
|
||||
public function serialize()
|
||||
{
|
||||
return json_encode(array(
|
||||
'status' => $this->statusCode,
|
||||
'body' => (string) $this->body,
|
||||
'headers' => $this->headers->toArray()
|
||||
));
|
||||
}
|
||||
|
||||
public function unserialize($serialize)
|
||||
{
|
||||
$data = json_decode($serialize, true);
|
||||
$this->__construct($data['status'], $data['headers'], $data['body']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response entity body
|
||||
*
|
||||
* @param bool $asString Set to TRUE to return a string of the body rather than a full body object
|
||||
*
|
||||
* @return EntityBodyInterface|string
|
||||
*/
|
||||
public function getBody($asString = false)
|
||||
{
|
||||
return $asString ? (string) $this->body : $this->body;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the response entity body
|
||||
*
|
||||
* @param EntityBodyInterface|string $body Body to set
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function setBody($body)
|
||||
{
|
||||
$this->body = EntityBody::factory($body);
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the protocol and protocol version of the response
|
||||
*
|
||||
* @param string $protocol Response protocol
|
||||
* @param string $version Protocol version
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function setProtocol($protocol, $version)
|
||||
{
|
||||
$this->protocol = $protocol;
|
||||
$this->protocolVersion = $version;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the protocol used for the response (e.g. HTTP)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getProtocol()
|
||||
{
|
||||
return $this->protocol;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the HTTP protocol version
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getProtocolVersion()
|
||||
{
|
||||
return $this->protocolVersion;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a cURL transfer information
|
||||
*
|
||||
* @param string $key A single statistic to check
|
||||
*
|
||||
* @return array|string|null Returns all stats if no key is set, a single stat if a key is set, or null if a key
|
||||
* is set and not found
|
||||
* @link http://www.php.net/manual/en/function.curl-getinfo.php
|
||||
*/
|
||||
public function getInfo($key = null)
|
||||
{
|
||||
if ($key === null) {
|
||||
return $this->info;
|
||||
} elseif (array_key_exists($key, $this->info)) {
|
||||
return $this->info[$key];
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the transfer information
|
||||
*
|
||||
* @param array $info Array of cURL transfer stats
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function setInfo(array $info)
|
||||
{
|
||||
$this->info = $info;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the response status
|
||||
*
|
||||
* @param int $statusCode Response status code to set
|
||||
* @param string $reasonPhrase Response reason phrase
|
||||
*
|
||||
* @return self
|
||||
* @throws BadResponseException when an invalid response code is received
|
||||
*/
|
||||
public function setStatus($statusCode, $reasonPhrase = '')
|
||||
{
|
||||
$this->statusCode = (int) $statusCode;
|
||||
|
||||
if (!$reasonPhrase && isset(self::$statusTexts[$this->statusCode])) {
|
||||
$this->reasonPhrase = self::$statusTexts[$this->statusCode];
|
||||
} else {
|
||||
$this->reasonPhrase = $reasonPhrase;
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response status code
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function getStatusCode()
|
||||
{
|
||||
return $this->statusCode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the entire response as a string
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getMessage()
|
||||
{
|
||||
$message = $this->getRawHeaders();
|
||||
|
||||
// Only include the body in the message if the size is < 2MB
|
||||
$size = $this->body->getSize();
|
||||
if ($size < 2097152) {
|
||||
$message .= (string) $this->body;
|
||||
}
|
||||
|
||||
return $message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the the raw message headers as a string
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getRawHeaders()
|
||||
{
|
||||
$headers = 'HTTP/1.1 ' . $this->statusCode . ' ' . $this->reasonPhrase . "\r\n";
|
||||
$lines = $this->getHeaderLines();
|
||||
if (!empty($lines)) {
|
||||
$headers .= implode("\r\n", $lines) . "\r\n";
|
||||
}
|
||||
|
||||
return $headers . "\r\n";
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the response reason phrase- a human readable version of the numeric
|
||||
* status code
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getReasonPhrase()
|
||||
{
|
||||
return $this->reasonPhrase;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Accept-Ranges HTTP header
|
||||
*
|
||||
* @return string Returns what partial content range types this server supports.
|
||||
*/
|
||||
public function getAcceptRanges()
|
||||
{
|
||||
return (string) $this->getHeader('Accept-Ranges');
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the age of the response
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function calculateAge()
|
||||
{
|
||||
$age = $this->getHeader('Age');
|
||||
|
||||
if ($age === null && $this->getDate()) {
|
||||
$age = time() - strtotime($this->getDate());
|
||||
}
|
||||
|
||||
return $age === null ? null : (int) (string) $age;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Age HTTP header
|
||||
*
|
||||
* @return integer|null Returns the age the object has been in a proxy cache in seconds.
|
||||
*/
|
||||
public function getAge()
|
||||
{
|
||||
return (string) $this->getHeader('Age');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Allow HTTP header
|
||||
*
|
||||
* @return string|null Returns valid actions for a specified resource. To be used for a 405 Method not allowed.
|
||||
*/
|
||||
public function getAllow()
|
||||
{
|
||||
return (string) $this->getHeader('Allow');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an HTTP method is allowed by checking the Allow response header
|
||||
*
|
||||
* @param string $method Method to check
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isMethodAllowed($method)
|
||||
{
|
||||
$allow = $this->getHeader('Allow');
|
||||
if ($allow) {
|
||||
foreach (explode(',', $allow) as $allowable) {
|
||||
if (!strcasecmp(trim($allowable), $method)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Cache-Control HTTP header
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCacheControl()
|
||||
{
|
||||
return (string) $this->getHeader('Cache-Control');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Connection HTTP header
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getConnection()
|
||||
{
|
||||
return (string) $this->getHeader('Connection');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Encoding HTTP header
|
||||
*
|
||||
* @return string|null
|
||||
*/
|
||||
public function getContentEncoding()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Encoding');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Language HTTP header
|
||||
*
|
||||
* @return string|null Returns the language the content is in.
|
||||
*/
|
||||
public function getContentLanguage()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Language');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Length HTTP header
|
||||
*
|
||||
* @return integer Returns the length of the response body in bytes
|
||||
*/
|
||||
public function getContentLength()
|
||||
{
|
||||
return (int) (string) $this->getHeader('Content-Length');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Location HTTP header
|
||||
*
|
||||
* @return string|null Returns an alternate location for the returned data (e.g /index.htm)
|
||||
*/
|
||||
public function getContentLocation()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Location');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Disposition HTTP header
|
||||
*
|
||||
* @return string|null Returns the Content-Disposition header
|
||||
*/
|
||||
public function getContentDisposition()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Disposition');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-MD5 HTTP header
|
||||
*
|
||||
* @return string|null Returns a Base64-encoded binary MD5 sum of the content of the response.
|
||||
*/
|
||||
public function getContentMd5()
|
||||
{
|
||||
return (string) $this->getHeader('Content-MD5');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Range HTTP header
|
||||
*
|
||||
* @return string Returns where in a full body message this partial message belongs (e.g. bytes 21010-47021/47022).
|
||||
*/
|
||||
public function getContentRange()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Range');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Content-Type HTTP header
|
||||
*
|
||||
* @return string Returns the mime type of this content.
|
||||
*/
|
||||
public function getContentType()
|
||||
{
|
||||
return (string) $this->getHeader('Content-Type');
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the Content-Type is of a certain type. This is useful if the
|
||||
* Content-Type header contains charset information and you need to know if
|
||||
* the Content-Type matches a particular type.
|
||||
*
|
||||
* @param string $type Content type to check against
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isContentType($type)
|
||||
{
|
||||
return stripos($this->getHeader('Content-Type'), $type) !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Date HTTP header
|
||||
*
|
||||
* @return string|null Returns the date and time that the message was sent.
|
||||
*/
|
||||
public function getDate()
|
||||
{
|
||||
return (string) $this->getHeader('Date');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the ETag HTTP header
|
||||
*
|
||||
* @return string|null Returns an identifier for a specific version of a resource, often a Message digest.
|
||||
*/
|
||||
public function getEtag()
|
||||
{
|
||||
return (string) $this->getHeader('ETag');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Expires HTTP header
|
||||
*
|
||||
* @return string|null Returns the date/time after which the response is considered stale.
|
||||
*/
|
||||
public function getExpires()
|
||||
{
|
||||
return (string) $this->getHeader('Expires');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Last-Modified HTTP header
|
||||
*
|
||||
* @return string|null Returns the last modified date for the requested object, in RFC 2822 format
|
||||
* (e.g. Tue, 15 Nov 1994 12:45:26 GMT)
|
||||
*/
|
||||
public function getLastModified()
|
||||
{
|
||||
return (string) $this->getHeader('Last-Modified');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Location HTTP header
|
||||
*
|
||||
* @return string|null Used in redirection, or when a new resource has been created.
|
||||
*/
|
||||
public function getLocation()
|
||||
{
|
||||
return (string) $this->getHeader('Location');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Pragma HTTP header
|
||||
*
|
||||
* @return Header|null Returns the implementation-specific headers that may have various effects anywhere along
|
||||
* the request-response chain.
|
||||
*/
|
||||
public function getPragma()
|
||||
{
|
||||
return (string) $this->getHeader('Pragma');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Proxy-Authenticate HTTP header
|
||||
*
|
||||
* @return string|null Authentication to access the proxy (e.g. Basic)
|
||||
*/
|
||||
public function getProxyAuthenticate()
|
||||
{
|
||||
return (string) $this->getHeader('Proxy-Authenticate');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Retry-After HTTP header
|
||||
*
|
||||
* @return int|null If an entity is temporarily unavailable, this instructs the client to try again after a
|
||||
* specified period of time.
|
||||
*/
|
||||
public function getRetryAfter()
|
||||
{
|
||||
return (string) $this->getHeader('Retry-After');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Server HTTP header
|
||||
*
|
||||
* @return string|null A name for the server
|
||||
*/
|
||||
public function getServer()
|
||||
{
|
||||
return (string) $this->getHeader('Server');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Set-Cookie HTTP header
|
||||
*
|
||||
* @return string|null An HTTP cookie.
|
||||
*/
|
||||
public function getSetCookie()
|
||||
{
|
||||
return (string) $this->getHeader('Set-Cookie');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Trailer HTTP header
|
||||
*
|
||||
* @return string|null The Trailer general field value indicates that the given set of header fields is present in
|
||||
* the trailer of a message encoded with chunked transfer-coding.
|
||||
*/
|
||||
public function getTrailer()
|
||||
{
|
||||
return (string) $this->getHeader('Trailer');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Transfer-Encoding HTTP header
|
||||
*
|
||||
* @return string|null The form of encoding used to safely transfer the entity to the user
|
||||
*/
|
||||
public function getTransferEncoding()
|
||||
{
|
||||
return (string) $this->getHeader('Transfer-Encoding');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Vary HTTP header
|
||||
*
|
||||
* @return string|null Tells downstream proxies how to match future request headers to decide whether the cached
|
||||
* response can be used rather than requesting a fresh one from the origin server.
|
||||
*/
|
||||
public function getVary()
|
||||
{
|
||||
return (string) $this->getHeader('Vary');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Via HTTP header
|
||||
*
|
||||
* @return string|null Informs the client of proxies through which the response was sent.
|
||||
*/
|
||||
public function getVia()
|
||||
{
|
||||
return (string) $this->getHeader('Via');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the Warning HTTP header
|
||||
*
|
||||
* @return string|null A general warning about possible problems with the entity body
|
||||
*/
|
||||
public function getWarning()
|
||||
{
|
||||
return (string) $this->getHeader('Warning');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the WWW-Authenticate HTTP header
|
||||
*
|
||||
* @return string|null Indicates the authentication scheme that should be used to access the requested entity
|
||||
*/
|
||||
public function getWwwAuthenticate()
|
||||
{
|
||||
return (string) $this->getHeader('WWW-Authenticate');
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is a Client Error (4xx)
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isClientError()
|
||||
{
|
||||
return $this->statusCode >= 400 && $this->statusCode < 500;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is Server OR Client Error (4xx or 5xx)
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isError()
|
||||
{
|
||||
return $this->isClientError() || $this->isServerError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is Information (1xx)
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isInformational()
|
||||
{
|
||||
return $this->statusCode < 200;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is a Redirect (3xx)
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isRedirect()
|
||||
{
|
||||
return $this->statusCode >= 300 && $this->statusCode < 400;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is Server Error (5xx)
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isServerError()
|
||||
{
|
||||
return $this->statusCode >= 500 && $this->statusCode < 600;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if HTTP Status code is Successful (2xx | 304)
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isSuccessful()
|
||||
{
|
||||
return ($this->statusCode >= 200 && $this->statusCode < 300) || $this->statusCode == 304;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the response can be cached based on the response headers
|
||||
*
|
||||
* @return bool Returns TRUE if the response can be cached or false if not
|
||||
*/
|
||||
public function canCache()
|
||||
{
|
||||
// Check if the response is cacheable based on the code
|
||||
if (!in_array((int) $this->getStatusCode(), self::$cacheResponseCodes)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Make sure a valid body was returned and can be cached
|
||||
if ((!$this->getBody()->isReadable() || !$this->getBody()->isSeekable())
|
||||
&& ($this->getContentLength() > 0 || $this->getTransferEncoding() == 'chunked')) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Never cache no-store resources (this is a private cache, so private
|
||||
// can be cached)
|
||||
if ($this->getHeader('Cache-Control') && $this->getHeader('Cache-Control')->hasDirective('no-store')) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $this->isFresh() || $this->getFreshness() === null || $this->canValidate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the number of seconds from the current time in which this response is still considered fresh
|
||||
*
|
||||
* @return int|null Returns the number of seconds
|
||||
*/
|
||||
public function getMaxAge()
|
||||
{
|
||||
if ($header = $this->getHeader('Cache-Control')) {
|
||||
// s-max-age, then max-age, then Expires
|
||||
if ($age = $header->getDirective('s-maxage')) {
|
||||
return $age;
|
||||
}
|
||||
if ($age = $header->getDirective('max-age')) {
|
||||
return $age;
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->getHeader('Expires')) {
|
||||
return strtotime($this->getExpires()) - time();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the response is considered fresh.
|
||||
*
|
||||
* A response is considered fresh when its age is less than or equal to the freshness lifetime (maximum age) of the
|
||||
* response.
|
||||
*
|
||||
* @return bool|null
|
||||
*/
|
||||
public function isFresh()
|
||||
{
|
||||
$fresh = $this->getFreshness();
|
||||
|
||||
return $fresh === null ? null : $fresh >= 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the response can be validated against the origin server using a conditional GET request.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function canValidate()
|
||||
{
|
||||
return $this->getEtag() || $this->getLastModified();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the freshness of the response by returning the difference of the maximum lifetime of the response and the
|
||||
* age of the response (max-age - age).
|
||||
*
|
||||
* Freshness values less than 0 mean that the response is no longer fresh and is ABS(freshness) seconds expired.
|
||||
* Freshness values of greater than zero is the number of seconds until the response is no longer fresh. A NULL
|
||||
* result means that no freshness information is available.
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getFreshness()
|
||||
{
|
||||
$maxAge = $this->getMaxAge();
|
||||
$age = $this->calculateAge();
|
||||
|
||||
return $maxAge && $age ? ($maxAge - $age) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the JSON response body and return an array
|
||||
*
|
||||
* @return array|string|int|bool|float
|
||||
* @throws RuntimeException if the response body is not in JSON format
|
||||
*/
|
||||
public function json()
|
||||
{
|
||||
$data = json_decode((string) $this->body, true);
|
||||
if (JSON_ERROR_NONE !== json_last_error()) {
|
||||
throw new RuntimeException('Unable to parse response body into JSON: ' . json_last_error());
|
||||
}
|
||||
|
||||
return $data === null ? array() : $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the XML response body and return a \SimpleXMLElement.
|
||||
*
|
||||
* In order to prevent XXE attacks, this method disables loading external
|
||||
* entities. If you rely on external entities, then you must parse the
|
||||
* XML response manually by accessing the response body directly.
|
||||
*
|
||||
* @return \SimpleXMLElement
|
||||
* @throws RuntimeException if the response body is not in XML format
|
||||
* @link http://websec.io/2012/08/27/Preventing-XXE-in-PHP.html
|
||||
*/
|
||||
public function xml()
|
||||
{
|
||||
$errorMessage = null;
|
||||
$internalErrors = libxml_use_internal_errors(true);
|
||||
$disableEntities = libxml_disable_entity_loader(true);
|
||||
libxml_clear_errors();
|
||||
|
||||
try {
|
||||
$xml = new \SimpleXMLElement((string) $this->body ?: '<root />', LIBXML_NONET);
|
||||
if ($error = libxml_get_last_error()) {
|
||||
$errorMessage = $error->message;
|
||||
}
|
||||
} catch (\Exception $e) {
|
||||
$errorMessage = $e->getMessage();
|
||||
}
|
||||
|
||||
libxml_clear_errors();
|
||||
libxml_use_internal_errors($internalErrors);
|
||||
libxml_disable_entity_loader($disableEntities);
|
||||
|
||||
if ($errorMessage) {
|
||||
throw new RuntimeException('Unable to parse response body into XML: ' . $errorMessage);
|
||||
}
|
||||
|
||||
return $xml;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the redirect count of this response
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getRedirectCount()
|
||||
{
|
||||
return (int) $this->params->get(RedirectPlugin::REDIRECT_COUNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the effective URL that resulted in this response (e.g. the last redirect URL)
|
||||
*
|
||||
* @param string $url The effective URL
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function setEffectiveUrl($url)
|
||||
{
|
||||
$this->effectiveUrl = $url;
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the effective URL that resulted in this response (e.g. the last redirect URL)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getEffectiveUrl()
|
||||
{
|
||||
return $this->effectiveUrl;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
* @codeCoverageIgnore
|
||||
*/
|
||||
public function getPreviousResponse()
|
||||
{
|
||||
Version::warn(__METHOD__ . ' is deprecated. Use the HistoryPlugin.');
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
* @codeCoverageIgnore
|
||||
*/
|
||||
public function setRequest($request)
|
||||
{
|
||||
Version::warn(__METHOD__ . ' is deprecated');
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
* @codeCoverageIgnore
|
||||
*/
|
||||
public function getRequest()
|
||||
{
|
||||
Version::warn(__METHOD__ . ' is deprecated');
|
||||
return null;
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue