Viewing file:  RemoteContentRequest.php (9.98 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
class RemoteContentRequest {
// these are used for making the request
private $uri = '';
// to get real url after signed requests
private $notSignedUri = '';
private $method = '';
private $headers = array();
private $postBody = false;
// these fields are filled in once the request has completed
private $responseContent = false;
private $responseSize = false;
private $responseHeaders = array();
private $metadata = array();
private $httpCode = false;
private $httpCodeMsg = '';
private $contentType = null;
private $created;
private $refreshInterval;
private static $SC_OK = 200; //Please, use only for testing!
public $handle = false;
public static $DEFAULT_CONTENT_TYPE = "application/x-www-form-urlencoded; charset=utf-8";
/**
* @var Options
*/
private $options;
/**
* @var SecurityToken
*/
private $token;
/**
* @var string
*/
private $invalidation;
public static $AUTH_NONE = 'none';
public static $AUTH_SIGNED = 'signed';
public static $AUTH_OAUTH = 'oauth';
/**
* @var string
*/
private $authType;
/**
* @var OAuthRequestParams
*/
private $oauthParams = null;
public function __construct($uri, $headers = false, $postBody = false) {
$this->uri = $uri;
$this->notSignedUri = $uri;
$this->headers = $headers;
$this->postBody = $postBody;
$this->created = time();
$this->authType = self::$AUTH_NONE;
}
public function createRemoteContentRequest($method, $uri, $headers, $postBody, $options) {
$this->method = $method;
$this->uri = $uri;
$this->options = $options;
// Copy the headers
if (! isset($headers)) {
$this->headers = '';
} else {
$setPragmaHeader = false;
$tmpHeaders = '';
foreach ($headers as $key => $value) {
// Proxies should be bypassed with the Pragma: no-cache check.
if ($key == "Pragma" && $options->ignoreCache) {
$value = "no-cache";
$setPragmaHeader = true;
}
$tmpHeaders .= $key . ":" . $value . "\n";
}
// Bypass caching in proxies as well.
if (! $setPragmaHeader && $options->ignoreCache) {
$tmpHeaders .= "Pragma: no-cache\n";
}
$this->headers = $tmpHeaders;
}
if (! isset($postBody)) {
$this->postBody = '';
} else {
$this->postBody = array_merge($postBody, $this->postBody);
}
$type = $this->getHeader("Content-Type");
if (! isset($type)) {
$this->contentType = RemoteContentRequest::$DEFAULT_CONTENT_TYPE;
} else {
$this->contentType = $type;
}
}
/**
* Basic GET request.
*
* @param uri
*/
public function createRemoteContentRequestWithUri($uri) {
$this->createRemoteContentRequest("GET", $uri, null, null, RemoteContentRequest::getDefaultOptions());
}
/**
* Returns a hash code which identifies this request, used for caching, takes method, url, authType and headers
* into account for constructing the md5 checksum
* NOTE: the postBody is excluded so that the GadgetHrefRenderer can use cached requests without having to
* fetch the data-pipeling social data first
* @return string md5 checksum
*/
public function toHash() {
return md5($this->method . $this->uri . $this->authType . $this->headers);
}
public static function getDefaultOptions() {
return new Options();
}
public function getContentType() {
return $this->contentType;
}
public function getHttpCode() {
return $this->httpCode;
}
public function getHttpCodeMsg() {
return $this->httpCodeMsg;
}
public function getResponseContent() {
return $this->responseContent;
}
public function getResponseHeaders() {
return $this->responseHeaders;
}
public function getResponseSize() {
return $this->responseSize;
}
public function getHeaders() {
return $this->headers;
}
public function isPost() {
return ($this->postBody != false);
}
public function hasHeaders() {
return ! empty($this->headers);
}
public function getPostBody() {
return $this->postBody;
}
public function getUrl() {
return $this->uri;
}
public function getNotSignedUrl() {
return $this->notSignedUri;
}
public function getMethod() {
if ($this->method) {
return $this->method;
}
if ($this->postBody) {
return 'POST';
} else {
return 'GET';
}
}
public function setMethod($method) {
$this->method = $method;
}
/**
* @return Options
*/
public function getOptions() {
if (empty($this->options)) {
$this->options = new Options();
}
return $this->options;
}
public function setContentType($type) {
$this->contentType = $type;
}
public function setHttpCode($code) {
$this->httpCode = intval($code);
}
public function setHttpCodeMsg($msg) {
$this->httpCodeMsg = $msg;
}
public function setResponseContent($content) {
$this->responseContent = $content;
}
public function setResponseHeader($headerName, $headerValue) {
$this->responseHeaders[$headerName] = $headerValue;
}
public function setResponseHeaders($headers) {
$this->responseHeaders = $headers;
}
public function setResponseSize($size) {
$this->responseSize = intval($size);
}
public function setHeaders($headers) {
$this->headers = $headers;
}
//FIXME: Find a better way to do this
// The headers can be an array of elements.
public function getHeader($headerName) {
$headers = explode("\n", $this->headers);
foreach ($headers as $header) {
$key = explode(":", $header, 2);
if (strtolower(trim($key[0])) == strtolower($headerName)) return trim($key[1]);
}
return null;
}
public function getResponseHeader($headerName) {
return isset($this->responseHeaders[$headerName]) ? $this->responseHeaders[$headerName] : null;
}
public function getCreated() {
return $this->created;
}
public function setPostBody($postBody) {
$this->postBody = $postBody;
}
public function setUri($uri) {
$this->uri = $uri;
}
public function setNotSignedUri($uri) {
$this->notSignedUri = $uri;
}
public function setInvalidation($invalidation) {
$this->invalidation = $invalidation;
}
public function getInvalidation() {
return $this->invalidation;
}
/**
* Sets the security token to use (used if the request has authorization set (signed, oauth))
* @param SecurityToken $token
*/
public function setToken($token) {
$this->token = $token;
}
/**
* Returns the SecurityToken for this request
*
* @return SecurityToken
*/
public function getToken() {
return $this->token;
}
public function setOAuthRequestParams(OAuthRequestParams $params) {
$this->oauthParams = $params;
}
/**
* @return OAuthRequestParams
*/
public function getOAuthRequestParams() {
return $this->oauthParams;
}
/**
* Sets the authorization type for this request, can be one of
* - none, no signing or authorization
* - signed, sign the request with an oauth_signature
* - oauth, logges in to the remote oauth service and uses it as base for signing the requests
*
* @param string $type ('none', 'signed', 'oauth')
*/
public function setAuthType($type) {
$this->authType = $type;
}
/**
* Returns the auth type of the request
*
* @return string ('none', 'signed', 'oauth')
*/
public function getAuthType() {
return $this->authType;
}
/**
* Sets the cache refresh interval to use for this request
*
* @param int $refreshInterval (in seconds)
*/
public function setRefreshInterval($refreshInterval) {
$this->refreshInterval = $refreshInterval;
}
/**
* Returns the cache's refresh interval for this request
*
* @return int refreshInterval (in seconds)
*/
public function getRefreshInterval() {
return $this->refreshInterval;
}
public function setMetadata($key, $value) {
$this->metadata[$key] = $value;
}
public function getMetadatas() {
return $this->metadata;
}
public function isStrictNoCache() {
$cacheControl = $this->getResponseHeader('Cache-Control');
if ($cacheControl != null) {
$directives = explode(',', $cacheControl);
foreach ($directives as $directive) {
if (strcasecmp($directive, 'no-cache') == 0
|| strcasecmp($directive, 'no-store') == 0
|| strcasecmp($directive, 'private') == 0) {
return true;
}
}
}
$progmas = $this->getResponseHeader('Progma');
if ($progmas != null) {
foreach ($progmas as $progma) {
if (strcasecmp($progma, 'no-cache') == 0) {
return true;
}
}
}
return false;
}
}
/**
* Bag of options for making a request.
*
* This object is mutable to keep us sane. Don't mess with it once you've
* sent it to RemoteContentRequest or bad things might happen.
*/
class Options {
public $ignoreCache = false;
public $ownerSigned = true;
public $viewerSigned = true;
public function __construct() {}
/**
* Copy constructor
*/
public function copyOptions(Options $copyFrom) {
$this->ignoreCache = $copyFrom->ignoreCache;
$this->ownerSigned = $copyFrom->ownerSigned;
$this->viewerSigned = $copyFrom->viewerSigned;
}
}
|