/**
* Tests getRateReset method
*/
public function testRateReset()
{
$response = new Response(200);
$response->setHeader('X-Rate-Reset', '100');
$client = new GenderizeClient();
$client->setLastResponse($response);
$this->assertEquals('100', $client->getRateReset());
}
public function writeHead($status = 200, array $headers = array())
{
if ($this->headWritten) {
throw new \Exception('Response head has already been written.');
}
if (isset($headers['Content-Length'])) {
$this->chunkedEncoding = false;
}
$response = new GuzzleResponse($status);
$response->setHeader('X-Powered-By', 'React/alpha');
$response->addHeaders($headers);
if ($this->chunkedEncoding) {
$response->setHeader('Transfer-Encoding', 'chunked');
}
$data = (string) $response;
$this->conn->write($data);
$this->headWritten = true;
}
/**
* {@inheritdoc}
*/
public function cache($key, Response $response, $ttl = null)
{
if ($ttl === null) {
$ttl = $this->defaultTtl;
}
if ($ttl) {
$response->setHeader('X-Guzzle-Cache', "key={$key}, ttl={$ttl}");
// Remove excluded headers from the response (see RFC 2616:13.5.1)
foreach ($this->excludeResponseHeaders as $header) {
$response->removeHeader($header);
}
// Add a Date header to the response if none is set (for validation)
if (!$response->getDate()) {
$response->setHeader('Date', Utils::getHttpDate('now'));
}
$this->cache->save($key, array($response->getStatusCode(), $response->getHeaders()->getAll(), $response->getBody(true)), $ttl);
}
}
public function cache($key, Response $response, $ttl = null)
{
if ($ttl === null) {
$ttl = $this->defaultTtl;
}
$ttl += $response->getMaxAge();
if ($ttl) {
$response->setHeader('X-Guzzle-Cache', "key={$key}; ttl={$ttl}");
// Remove excluded headers from the response (see RFC 2616:13.5.1)
foreach ($this->excludeResponseHeaders as $header) {
$response->removeHeader($header);
}
// Add a Date header to the response if none is set (for validation)
if (!$response->getDate()) {
$response->setHeader('Date', gmdate(ClientInterface::HTTP_DATE));
}
$this->cache->save($key, array($response->getStatusCode(), $response->getHeaders()->toArray(), $response->getBody(true)), $ttl);
}
}
public function writeHead($status = 200, array $headers = array())
{
if ($this->headWritten) {
throw new \Exception('Response head has already been written.');
}
$response = new GuzzleResponse($status, $headers);
$response->setHeader('X-Powered-By', 'React/alpha');
$data = (string) $response;
$this->conn->write($data);
$this->headWritten = true;
}
/**
* Reads response meta tags to guess content-type charset.
*/
protected function createResponse(GuzzleResponse $response)
{
$body = $response->getBody(true);
$contentType = $response->getContentType();
if (!$contentType || false === strpos($contentType, 'charset=')) {
if (preg_match('/\\<meta[^\\>]+charset *= *["\']?([a-zA-Z\\-0-9]+)/i', $body, $matches)) {
$contentType .= ';charset=' . $matches[1];
}
}
$response->setHeader('Content-Type', $contentType);
return parent::createResponse($response);
}
/**
* Check if a response in cache will satisfy the request before sending
*
* @param Event $event
*/
public function onRequestBeforeSend(Event $event)
{
$request = $event['request'];
if (!$this->canCache->canCacheRequest($request)) {
return;
}
$hashKey = $this->keyProvider->getCacheKey($request);
$this->cached[$request] = $hashKey;
// If the cached data was found, then make the request into a
// manually set request
if ($cachedData = $this->storage->fetch($hashKey)) {
unset($this->cached[$request]);
$response = new Response($cachedData[0], $cachedData[1], $cachedData[2]);
$response->setHeader('Age', time() - strtotime($response->getDate() ?: 'now'));
if (!$response->hasHeader('X-Guzzle-Cache')) {
$response->setHeader('X-Guzzle-Cache', "key={$hashKey}");
}
// Validate that the response satisfies the request
if ($this->canResponseSatisfyRequest($request, $response)) {
$request->setResponse($response);
}
}
}
/**
* Add the plugin's headers to a response
*
* @param RequestInterface $request Request
* @param Response $response Response to add headers to
*/
protected function addResponseHeaders(RequestInterface $request, Response $response)
{
$params = $request->getParams();
$response->setHeader('Via', sprintf('%s GuzzleCache/%s', $request->getProtocolVersion(), Version::VERSION));
$lookup = ($params['cache.lookup'] === true ? 'HIT' : 'MISS') . ' from GuzzleCache';
if ($header = $response->getHeader('X-Cache-Lookup')) {
// Don't add duplicates
$values = $header->toArray();
$values[] = $lookup;
$response->setHeader('X-Cache-Lookup', array_unique($values));
} else {
$response->setHeader('X-Cache-Lookup', $lookup);
}
if ($params['cache.hit'] === true) {
$xcache = 'HIT from GuzzleCache';
} elseif ($params['cache.hit'] == 'error') {
$xcache = 'HIT_ERROR from GuzzleCache';
} else {
$xcache = 'MISS from GuzzleCache';
}
if ($header = $response->getHeader('X-Cache')) {
// Don't add duplicates
$values = $header->toArray();
$values[] = $xcache;
$response->setHeader('X-Cache', array_unique($values));
} else {
$response->setHeader('X-Cache', $xcache);
}
if ($response->isFresh() === false) {
$response->addHeader('Warning', sprintf('110 GuzzleCache/%s "Response is stale"', Version::VERSION));
if ($params['cache.hit'] === 'error') {
$response->addHeader('Warning', sprintf('111 GuzzleCache/%s "Revalidation failed"', Version::VERSION));
}
}
}
/**
* Save data to the cache adapter
*
* @param string $key The cache key
* @param Response $response The response to cache
* @param int $lifetime Amount of seconds to cache
*
* @return int Returns the lifetime of the cached data
*/
protected function saveCache($key, Response $response, $lifetime = null)
{
$lifetime = $lifetime ?: $this->defaultLifetime;
// If the data is cacheable, then save it to the cache adapter
if ($lifetime) {
// Remove excluded headers from the response (see RFC 2616:13.5.1)
foreach ($this->excludeResponseHeaders as $header) {
$response->removeHeader($header);
}
// Add a Date header to the response if none is set (for validation)
if (!$response->getDate()) {
$response->setHeader('Date', Utils::getHttpDate('now'));
}
$data = array('c' => $response->getStatusCode(), 'h' => $response->getHeaders(), 'b' => $response->getBody(true));
if ($this->serialize) {
$data = serialize($data);
}
$this->getCacheAdapter()->save($key, $data, $lifetime);
}
return $lifetime;
}
/**
* @covers Guzzle\Http\Message\Response::getFreshness
* @covers Guzzle\Http\Message\Response::isFresh
*/
public function testCalculatesFreshness()
{
$response = new Response(200);
$this->assertNull($response->isFresh());
$this->assertNull($response->getFreshness());
$response->addCacheControlDirective('max-age', 120);
$response->setHeader('Age', 100);
$this->assertEquals(20, $response->getFreshness());
$this->assertTrue($response->isFresh());
$response->setHeader('Age', 150);
$this->assertEquals(-30, $response->getFreshness());
$this->assertFalse($response->isFresh());
}
/**
* Handle a 304 response and ensure that it is still valid
*
* @param RequestInterface $request Request that was sent
* @param Response $validateResponse Response received
* @param Response $response Original cached response
*
* @return bool Returns true if valid, false if invalid
*/
protected function handle304Response(RequestInterface $request, Response $validateResponse, Response $response)
{
static $replaceHeaders = array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified');
// Make sure that this response has the same ETag
if ($validateResponse->getEtag() != $response->getEtag()) {
return false;
}
// Replace cached headers with any of these headers from the
// origin server that might be more up to date
$modified = false;
foreach ($replaceHeaders as $name) {
if ($validateResponse->hasHeader($name)) {
$modified = true;
$response->setHeader($name, $validateResponse->getHeader($name));
}
}
// Store the updated response in cache
if ($modified && $this->canCache->canCacheResponse($response)) {
$this->storage->cache($request, $response);
}
return true;
}
/**
* Add the plugin's headers to a response
*
* @param string $cacheKey Cache key
* @param RequestInterface $request Request
* @param Response $response Response to add headers to
*/
protected function addResponseHeaders($cacheKey, RequestInterface $request, Response $response)
{
if (!$response->hasHeader('X-Guzzle-Cache')) {
$response->setHeader('X-Guzzle-Cache', "key={$cacheKey}");
}
$response->addHeader('Via', sprintf('%s GuzzleCache/%s', $request->getProtocolVersion(), Version::VERSION));
if ($this->debugHeaders) {
if ($request->getParams()->get('cache.lookup') === true) {
$response->addHeader('X-Cache-Lookup', 'HIT from GuzzleCache');
} else {
$response->addHeader('X-Cache-Lookup', 'MISS from GuzzleCache');
}
if ($request->getParams()->get('cache.hit') === true) {
$response->addHeader('X-Cache', 'HIT from GuzzleCache');
} elseif ($request->getParams()->get('cache.hit') === 'error') {
$response->addHeader('X-Cache', 'HIT_ERROR from GuzzleCache');
} else {
$response->addHeader('X-Cache', 'MISS from GuzzleCache');
}
}
if ($response->isFresh() === false) {
$response->addHeader('Warning', sprintf('110 GuzzleCache/%s "Response is stale"', Version::VERSION));
if ($request->getParams()->get('cache.hit') === 'error') {
$response->addHeader('Warning', sprintf('111 GuzzleCache/%s "Revalidation failed"', Version::VERSION));
}
}
}
protected function handle304Response(RequestInterface $request, Response $validateResponse, Response $response)
{
static $replaceHeaders = array('Date', 'Expires', 'Cache-Control', 'ETag', 'Last-Modified');
if ($validateResponse->getEtag() != $response->getEtag()) {
return false;
}
$modified = false;
foreach ($replaceHeaders as $name) {
if ($validateResponse->hasHeader($name)) {
$modified = true;
$response->setHeader($name, $validateResponse->getHeader($name));
}
}
if ($modified && $this->canCache->canCacheResponse($response)) {
$this->storage->cache($request, $response);
}
return true;
}
