Proyectos de Subversion Moodle

<?php

/*

 * Copyright 2013 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.

 */

/**

 * Abstract IO base class

 */

if (!class_exists('Google_Client')) {

  require_once dirname(__FILE__) . '/../autoload.php';

}

abstract class Google_IO_Abstract

{

  const UNKNOWN_CODE = 0;

  const FORM_URLENCODED = 'application/x-www-form-urlencoded';

  private static $CONNECTION_ESTABLISHED_HEADERS = array(

    "HTTP/1.0 200 Connection established\r\n\r\n",

    "HTTP/1.1 200 Connection established\r\n\r\n",

  );

  private static $ENTITY_HTTP_METHODS = array("POST" => null, "PUT" => null);

  private static $HOP_BY_HOP = array(

    'connection' => true,

    'keep-alive' => true,

    'proxy-authenticate' => true,

    'proxy-authorization' => true,

    'te' => true,

    'trailers' => true,

    'transfer-encoding' => true,

    'upgrade' => true

  );

  /** @var Google_Client */

  protected $client;

  public function __construct(Google_Client $client)

  {

    $this->client = $client;

    $timeout = $client->getClassConfig('Google_IO_Abstract', 'request_timeout_seconds');

    if ($timeout > 0) {

      $this->setTimeout($timeout);

    }

  }

  /**

   * Executes a Google_Http_Request

   * @param Google_Http_Request $request the http request to be executed

   * @return array containing response headers, body, and http code

   * @throws Google_IO_Exception on curl or IO error

   */

  abstract public function executeRequest(Google_Http_Request $request);

  /**

   * Set options that update the transport implementation's behavior.

   * @param $options

   */

  abstract public function setOptions($options);

  /**

   * Set the maximum request time in seconds.

   * @param $timeout in seconds

   */

  abstract public function setTimeout($timeout);

  /**

   * Get the maximum request time in seconds.

   * @return timeout in seconds

   */

  abstract public function getTimeout();

  /**

   * Test for the presence of a cURL header processing bug

   *

   * The cURL bug was present in versions prior to 7.30.0 and caused the header

   * length to be miscalculated when a "Connection established" header added by

   * some proxies was present.

   *

   * @return boolean

   */

  abstract protected function needsQuirk();

  /**

   * @visible for testing.

   * Cache the response to an HTTP request if it is cacheable.

   * @param Google_Http_Request $request

   * @return bool Returns true if the insertion was successful.

   * Otherwise, return false.

   */

  public function setCachedRequest(Google_Http_Request $request)

  {

    // Determine if the request is cacheable.

    if (Google_Http_CacheParser::isResponseCacheable($request)) {

      $this->client->getCache()->set($request->getCacheKey(), $request);

      return true;

    }

    return false;

  }

  /**

   * Execute an HTTP Request

   *

   * @param Google_Http_Request $request the http request to be executed

   * @return Google_Http_Request http request with the response http code,

   * response headers and response body filled in

   * @throws Google_IO_Exception on curl or IO error

   */

  public function makeRequest(Google_Http_Request $request)

  {

    // First, check to see if we have a valid cached version.

    $cached = $this->getCachedRequest($request);

    if ($cached !== false && $cached instanceof Google_Http_Request) {

      if (!$this->checkMustRevalidateCachedRequest($cached, $request)) {

        return $cached;

      }

    }

    if (array_key_exists($request->getRequestMethod(), self::$ENTITY_HTTP_METHODS)) {

      $request = $this->processEntityRequest($request);

    }

    list($responseData, $responseHeaders, $respHttpCode) = $this->executeRequest($request);

    if ($respHttpCode == 304 && $cached) {

      // If the server responded NOT_MODIFIED, return the cached request.

      $this->updateCachedRequest($cached, $responseHeaders);

      return $cached;

    }

    if (!isset($responseHeaders['Date']) && !isset($responseHeaders['date'])) {

      $responseHeaders['date'] = date("r");

    }

    $request->setResponseHttpCode($respHttpCode);

    $request->setResponseHeaders($responseHeaders);

    $request->setResponseBody($responseData);

    // Store the request in cache (the function checks to see if the request

    // can actually be cached)

    $this->setCachedRequest($request);

    return $request;

  }

  /**

   * @visible for testing.

   * @param Google_Http_Request $request

   * @return Google_Http_Request|bool Returns the cached object or

   * false if the operation was unsuccessful.

   */

  public function getCachedRequest(Google_Http_Request $request)

  {

    if (false === Google_Http_CacheParser::isRequestCacheable($request)) {

      return false;

    }

    return $this->client->getCache()->get($request->getCacheKey());

  }

  /**

   * @visible for testing

   * Process an http request that contains an enclosed entity.

   * @param Google_Http_Request $request

   * @return Google_Http_Request Processed request with the enclosed entity.

   */

  public function processEntityRequest(Google_Http_Request $request)

  {

    $postBody = $request->getPostBody();

    $contentType = $request->getRequestHeader("content-type");

    // Set the default content-type as application/x-www-form-urlencoded.

    if (false == $contentType) {

      $contentType = self::FORM_URLENCODED;

      $request->setRequestHeaders(array('content-type' => $contentType));

    }

    // Force the payload to match the content-type asserted in the header.

    if ($contentType == self::FORM_URLENCODED && is_array($postBody)) {

      $postBody = http_build_query($postBody, '', '&');

      $request->setPostBody($postBody);

    }

    // Make sure the content-length header is set.

    if (!$postBody || is_string($postBody)) {

      $postsLength = strlen($postBody);

      $request->setRequestHeaders(array('content-length' => $postsLength));

    }

    return $request;

  }

  /**

   * Check if an already cached request must be revalidated, and if so update

   * the request with the correct ETag headers.

   * @param Google_Http_Request $cached A previously cached response.

   * @param Google_Http_Request $request The outbound request.

   * return bool If the cached object needs to be revalidated, false if it is

   * still current and can be re-used.

   */

  protected function checkMustRevalidateCachedRequest($cached, $request)

  {

    if (Google_Http_CacheParser::mustRevalidate($cached)) {

      $addHeaders = array();

      if ($cached->getResponseHeader('etag')) {

        // [13.3.4] If an entity tag has been provided by the origin server,

        // we must use that entity tag in any cache-conditional request.

        $addHeaders['If-None-Match'] = $cached->getResponseHeader('etag');

      } elseif ($cached->getResponseHeader('date')) {

        $addHeaders['If-Modified-Since'] = $cached->getResponseHeader('date');

      }

      $request->setRequestHeaders($addHeaders);

      return true;

    } else {

      return false;

    }

  }

  /**

   * Update a cached request, using the headers from the last response.

   * @param Google_Http_Request $cached A previously cached response.

   * @param mixed Associative array of response headers from the last request.

   */

  protected function updateCachedRequest($cached, $responseHeaders)

  {

    $hopByHop = self::$HOP_BY_HOP;

    if (!empty($responseHeaders['connection'])) {

      $connectionHeaders = array_map(

          'strtolower',

          array_filter(

              array_map('trim', explode(',', $responseHeaders['connection']))

          )

      );

      $hopByHop += array_fill_keys($connectionHeaders, true);

    }

    $endToEnd = array_diff_key($responseHeaders, $hopByHop);

    $cached->setResponseHeaders($endToEnd);

  }

  /**

   * Used by the IO lib and also the batch processing.

   *

   * @param $respData

   * @param $headerSize

   * @return array

   */

  public function parseHttpResponse($respData, $headerSize)

  {

    // check proxy header

    foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {

      if (stripos($respData, $established_header) !== false) {

        // existed, remove it

        $respData = str_ireplace($established_header, '', $respData);

        // Subtract the proxy header size unless the cURL bug prior to 7.30.0

        // is present which prevented the proxy header size from being taken into

        // account.

        if (!$this->needsQuirk()) {

          $headerSize -= strlen($established_header);

        }

        break;

      }

    }

    if ($headerSize) {

      $responseBody = substr($respData, $headerSize);

      $responseHeaders = substr($respData, 0, $headerSize);

    } else {

      $responseSegments = explode("\r\n\r\n", $respData, 2);

      $responseHeaders = $responseSegments[0];

      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] :

                                                    null;

    }

    $responseHeaders = $this->getHttpResponseHeaders($responseHeaders);

    return array($responseHeaders, $responseBody);

  }

  /**

   * Parse out headers from raw headers

   * @param rawHeaders array or string

   * @return array

   */

  public function getHttpResponseHeaders($rawHeaders)

  {

    if (is_array($rawHeaders)) {

      return $this->parseArrayHeaders($rawHeaders);

    } else {

      return $this->parseStringHeaders($rawHeaders);

    }

  }

  private function parseStringHeaders($rawHeaders)

  {

    $headers = array();

    $responseHeaderLines = explode("\r\n", $rawHeaders);

    foreach ($responseHeaderLines as $headerLine) {

      if ($headerLine && strpos($headerLine, ':') !== false) {

        list($header, $value) = explode(': ', $headerLine, 2);

        $header = strtolower($header);

        if (isset($headers[$header])) {

          $headers[$header] .= "\n" . $value;

        } else {

          $headers[$header] = $value;

        }

      }

    }

    return $headers;

  }

  private function parseArrayHeaders($rawHeaders)

  {

    $header_count = count($rawHeaders);

    $headers = array();

    for ($i = 0; $i < $header_count; $i++) {

      $header = $rawHeaders[$i];

      // Times will have colons in - so we just want the first match.

      $header_parts = explode(': ', $header, 2);

      if (count($header_parts) == 2) {

        $headers[strtolower($header_parts[0])] = $header_parts[1];

      }

    }

    return $headers;

  }

}