PHP Classes
elePHPant
Icontem

File: example/GoogleClient/io/Google_CacheParser.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Vivek Muthal  >  Viv OAuth IMAP  >  example/GoogleClient/io/Google_CacheParser.php  >  Download  
File: example/GoogleClient/io/Google_CacheParser.php
Role: Example script
Content type: text/plain
Description: Example script
Class: Viv OAuth IMAP
Access messages in IMAP server using OAuth token
Author: By
Last change:
Date: 1 year ago
Size: 5,901 bytes
 

Contents

Class file image Download
<?php
/*
 * Copyright 2012 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * Implement the caching directives specified in rfc2616. This
 * implementation is guided by the guidance offered in rfc2616-sec13.
 * @author Chirag Shah <chirags@google.com>
 */
class Google_CacheParser {
  public static
$CACHEABLE_HTTP_METHODS = array('GET', 'HEAD');
  public static
$CACHEABLE_STATUS_CODES = array('200', '203', '300', '301');

  private function
__construct() {}

 
/**
   * Check if an HTTP request can be cached by a private local cache.
   *
   * @static
   * @param Google_HttpRequest $resp
   * @return bool True if the request is cacheable.
   * False if the request is uncacheable.
   */
 
public static function isRequestCacheable (Google_HttpRequest $resp) {
   
$method = $resp->getRequestMethod();
    if (!
in_array($method, self::$CACHEABLE_HTTP_METHODS)) {
      return
false;
    }

   
// Don't cache authorized requests/responses.
    // [rfc2616-14.8] When a shared cache receives a request containing an
    // Authorization field, it MUST NOT return the corresponding response
    // as a reply to any other request...
   
if ($resp->getRequestHeader("authorization")) {
      return
false;
    }

    return
true;
  }

 
/**
   * Check if an HTTP response can be cached by a private local cache.
   *
   * @static
   * @param Google_HttpRequest $resp
   * @return bool True if the response is cacheable.
   * False if the response is un-cacheable.
   */
 
public static function isResponseCacheable (Google_HttpRequest $resp) {
   
// First, check if the HTTP request was cacheable before inspecting the
    // HTTP response.
   
if (false == self::isRequestCacheable($resp)) {
      return
false;
    }

   
$code = $resp->getResponseHttpCode();
    if (!
in_array($code, self::$CACHEABLE_STATUS_CODES)) {
      return
false;
    }

   
// The resource is uncacheable if the resource is already expired and
    // the resource doesn't have an ETag for revalidation.
   
$etag = $resp->getResponseHeader("etag");
    if (
self::isExpired($resp) && $etag == false) {
      return
false;
    }

   
// [rfc2616-14.9.2] If [no-store is] sent in a response, a cache MUST NOT
    // store any part of either this response or the request that elicited it.
   
$cacheControl = $resp->getParsedCacheControl();
    if (isset(
$cacheControl['no-store'])) {
      return
false;
    }

   
// Pragma: no-cache is an http request directive, but is occasionally
    // used as a response header incorrectly.
   
$pragma = $resp->getResponseHeader('pragma');
    if (
$pragma == 'no-cache' || strpos($pragma, 'no-cache') !== false) {
      return
false;
    }

   
// [rfc2616-14.44] Vary: * is extremely difficult to cache. "It implies that
    // a cache cannot determine from the request headers of a subsequent request
    // whether this response is the appropriate representation."
    // Given this, we deem responses with the Vary header as uncacheable.
   
$vary = $resp->getResponseHeader('vary');
    if (
$vary) {
      return
false;
    }

    return
true;
  }

 
/**
   * @static
   * @param Google_HttpRequest $resp
   * @return bool True if the HTTP response is considered to be expired.
   * False if it is considered to be fresh.
   */
 
public static function isExpired(Google_HttpRequest $resp) {
   
// HTTP/1.1 clients and caches MUST treat other invalid date formats,
    // especially including the value “0”, as in the past.
   
$parsedExpires = false;
   
$responseHeaders = $resp->getResponseHeaders();
    if (isset(
$responseHeaders['expires'])) {
     
$rawExpires = $responseHeaders['expires'];
     
// Check for a malformed expires header first.
     
if (empty($rawExpires) || (is_numeric($rawExpires) && $rawExpires <= 0)) {
        return
true;
      }

     
// See if we can parse the expires header.
     
$parsedExpires = strtotime($rawExpires);
      if (
false == $parsedExpires || $parsedExpires <= 0) {
        return
true;
      }
    }

   
// Calculate the freshness of an http response.
   
$freshnessLifetime = false;
   
$cacheControl = $resp->getParsedCacheControl();
    if (isset(
$cacheControl['max-age'])) {
     
$freshnessLifetime = $cacheControl['max-age'];
    }

   
$rawDate = $resp->getResponseHeader('date');
   
$parsedDate = strtotime($rawDate);

    if (empty(
$rawDate) || false == $parsedDate) {
     
$parsedDate = time();
    }
    if (
false == $freshnessLifetime && isset($responseHeaders['expires'])) {
     
$freshnessLifetime = $parsedExpires - $parsedDate;
    }

    if (
false == $freshnessLifetime) {
      return
true;
    }

   
// Calculate the age of an http response.
   
$age = max(0, time() - $parsedDate);
    if (isset(
$responseHeaders['age'])) {
     
$age = max($age, strtotime($responseHeaders['age']));
    }

    return
$freshnessLifetime <= $age;
  }

 
/**
   * Determine if a cache entry should be revalidated with by the origin.
   *
   * @param Google_HttpRequest $response
   * @return bool True if the entry is expired, else return false.
   */
 
public static function mustRevalidate(Google_HttpRequest $response) {
   
// [13.3] When a cache has a stale entry that it would like to use as a
    // response to a client's request, it first has to check with the origin
    // server to see if its cached entry is still usable.
   
return self::isExpired($response);
  }
}