PHP Google_HttpRequest::getRequestMethod方法代码示例

 /**
  * Decode an HTTP Response.
  * @static
  * @throws Google_ServiceException
  * @param Google_HttpRequest $response The http response to be decoded.
  * @return mixed|null
  */
 public static function decodeHttpResponse($response)
 {
     $code = $response->getResponseHttpCode();
     $body = $response->getResponseBody();
     $decoded = null;
     if (intVal($code) >= 300) {
         $decoded = json_decode($body, true);
         $err = 'Error calling ' . $response->getRequestMethod() . ' ' . $response->getUrl();
         if ($decoded != null && isset($decoded['error']['message']) && isset($decoded['error']['code'])) {
             // if we're getting a json encoded error definition, use that instead of the raw response
             // body for improved readability
             $err .= ": ({$decoded['error']['code']}) {$decoded['error']['message']}";
         } else {
             $err .= ": ({$code}) {$body}";
         }
         throw new Google_ServiceException($err, $code, null, $decoded['error']['errors']);
     }
     // Only attempt to decode the response, if the response code wasn't (204) 'no content'
     if ($code != '204') {
         $decoded = json_decode($body, true);
         if ($decoded === null || $decoded === "") {
             throw new Google_ServiceException("Invalid json in service response: {$body}");
         }
     }
     return $decoded;
 }

 /**
  * 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;
 }

 /**
  * Send the request via our curl object.
  *
  * @param curl $curl prepared curl object.
  * @param Google_HttpRequest $request The request.
  * @return string result of the request.
  */
 private function do_request($curl, $request)
 {
     $url = $request->getUrl();
     $method = $request->getRequestMethod();
     switch (strtoupper($method)) {
         case 'POST':
             $ret = $curl->post($url, $request->getPostBody());
             break;
         case 'GET':
             $ret = $curl->get($url);
             break;
         case 'HEAD':
             $ret = $curl->head($url);
             break;
         case 'PUT':
             $ret = $curl->put($url);
             break;
         default:
             throw new coding_exception('Unknown request type: ' . $method);
             break;
     }
     return $ret;
 }

 /**
  * Send an API request to Google.
  *
  * This method overwrite the parent one so that the Google SDK will use our class
  * curl to proceed with the requests. This allows us to have control over the
  * proxy parameters and other stuffs.
  *
  * Note that the caching support of the Google SDK has been removed from this function.
  *
  * @param Google_HttpRequest $request the http request to be executed
  * @return Google_HttpRequest http request with the response http code, response
  * headers and response body filled in
  * @throws Google_IOException on curl or IO error
  */
 public function makeRequest(Google_HttpRequest $request)
 {
     if (array_key_exists($request->getRequestMethod(), self::$ENTITY_HTTP_METHODS)) {
         $request = $this->processEntityRequest($request);
     }
     $curl = new curl();
     $curl->setopt($this->curlParams);
     $curl->setopt(array('CURLOPT_URL' => $request->getUrl()));
     $requestHeaders = $request->getRequestHeaders();
     if ($requestHeaders && is_array($requestHeaders)) {
         $parsed = array();
         foreach ($requestHeaders as $k => $v) {
             $parsed[] = "{$k}: {$v}";
         }
         $curl->setHeader($parsed);
     }
     $curl->setopt(array('CURLOPT_CUSTOMREQUEST' => $request->getRequestMethod(), 'CURLOPT_USERAGENT' => $request->getUserAgent()));
     $respdata = $this->do_request($curl, $request);
     // Retry if certificates are missing.
     if ($curl->get_errno() == CURLE_SSL_CACERT) {
         error_log('SSL certificate problem, verify that the CA cert is OK.' . ' Retrying with the CA cert bundle from google-api-php-client.');
         $curl->setopt(array('CURLOPT_CAINFO' => dirname(__FILE__) . '/io/cacerts.pem'));
         $respdata = $this->do_request($curl, $request);
     }
     $infos = $curl->get_info();
     $respheadersize = $infos['header_size'];
     $resphttpcode = (int) $infos['http_code'];
     $curlerrornum = $curl->get_errno();
     $curlerror = $curl->error;
     if ($curlerrornum != CURLE_OK) {
         throw new Google_IOException("HTTP Error: ({$resphttpcode}) {$curlerror}");
     }
     // Parse out the raw response into usable bits.
     list($responseHeaders, $responseBody) = self::parseHttpResponse($respdata, $respheadersize);
     // Fill in the apiHttpRequest with the response values.
     $request->setResponseHttpCode($resphttpcode);
     $request->setResponseHeaders($responseHeaders);
     $request->setResponseBody($responseBody);
     return $request;
 }