/**
* Tests BasicRemoteContent->fetch() 404 response
*/
public function testFetch404()
{
$request = new RemoteContentRequest('http://test.chabotc.com/fail.html');
$context = new TestContext();
$ret = $this->BasicRemoteContent->fetch($request, $context);
$this->assertEquals('404', $ret->getHttpCode());
}
/**
* Retrieves a gadget specification from the Internet, processes its views and
* adds it to the cache.
*/
private function fetchFromWeb($url, $ignoreCache)
{
$remoteContentRequest = new RemoteContentRequest($url);
$remoteContentRequest->getOptions()->ignoreCache = $ignoreCache;
$remoteContent = new BasicRemoteContent();
$spec = $remoteContent->fetch($remoteContentRequest);
$gadgetSpecParser = new GadgetSpecParser();
$gadgetSpec = $gadgetSpecParser->parse($spec->getResponseContent());
return $gadgetSpec;
}
/**
* Retrieves a gadget specification from the Internet, processes its views and
* adds it to the cache.
*/
private function fetchFromWeb($url, $ignoreCache)
{
$remoteContentRequest = new RemoteContentRequest($url);
$remoteContentRequest->getOptions()->ignoreCache = $ignoreCache;
$remoteContent = new BasicRemoteContent();
$spec = $remoteContent->fetch($remoteContentRequest);
$gadgetSpecParserClass = Config::get('gadget_spec_parser');
$gadgetSpecParser = new $gadgetSpecParserClass();
$gadgetSpec = $gadgetSpecParser->parse($spec->getResponseContent(), $this->context);
return $gadgetSpec;
}
/**
* Makes a request for remote data.
*
* @param GadgetContext $context Gadget context used to make the request.
* @param MakeRequestOptions $params Parameter array used to configure the remote request.
* @return RemoteContentRequest A request/response which has been sent to the target server.
*/
public function fetch(GadgetContext $context, MakeRequestOptions $params)
{
$signingFetcherFactory = $gadgetSigner = null;
if ($params->getAuthz() == "SIGNED" || $params->getAuthz() == "OAUTH") {
$gadgetSigner = Config::get('security_token_signer');
$gadgetSigner = new $gadgetSigner();
$signingFetcherFactory = new SigningFetcherFactory(Config::get("private_key_file"));
}
$basicRemoteContent = new BasicRemoteContent($this->remoteFetcher, $signingFetcherFactory, $gadgetSigner);
$request = $this->buildRequest($context, $params, $gadgetSigner);
$request->getOptions()->ignoreCache = $params->getNoCache();
$request->getOptions()->viewerSigned = $params->getSignViewer();
$request->getOptions()->ownerSigned = $params->getSignOwner();
$result = $basicRemoteContent->fetch($request);
$status = (int) $result->getHttpCode();
if ($status == 200) {
switch ($params->getResponseFormat()) {
case 'FEED':
$content = $this->parseFeed($result, $params->getHref(), $params->getNumEntries(), $params->getGetSummaries());
$result->setResponseContent($content);
break;
}
}
if ((strpos($result->getContentType(), 'text') !== false || strpos($result->getContentType(), 'application') !== false) && strpos($result->getResponseContent(), '\\u')) {
$result->setResponseContent($this->decodeUtf8($result->getResponseContent()));
}
return $result;
}
/**
* Peforms the actual http fetching of the data-pipelining requests, all social requests
* are made to $_SERVER['HTTP_HOST'] (the virtual host name of this server) / (optional) web_prefix / social / rpc, and
* the httpRequest's are made to $_SERVER['HTTP_HOST'] (the virtual host name of this server) / (optional) web_prefix / gadgets / makeRequest
* both request types use the current security token ($_GET['st']) when performing the requests so they happen in the correct context
*
* @param array $requests
* @return array response
*/
private static function performRequests($requests, $context)
{
$jsonRequests = array();
$httpRequests = array();
$decodedResponse = array();
// Using the same gadget security token for all social & http requests so everything happens in the right context
if (!isset($_GET['st'])) {
throw new ExpressionException("No security token set, required for data-pipeling");
}
$securityToken = $_GET['st'];
foreach ($requests as $request) {
switch ($request['type']) {
case 'os:DataRequest':
// Add to the social request batch
$id = $request['key'];
$method = $request['method'];
// remove our internal fields so we can use the remainder as params
unset($request['key']);
unset($request['method']);
unset($request['type']);
if (isset($request['fields'])) {
$request['fields'] = explode(',', $request['fields']);
}
$jsonRequests[] = array('method' => $method, 'id' => $id, 'params' => $request);
break;
case 'os:HttpRequest':
$id = $request['key'];
$url = $request['href'];
$format = isset($request['format']) ? $request['format'] : 'json';
unset($request['key']);
unset($request['type']);
unset($request['href']);
$httpRequests[$url] = array('id' => $id, 'url' => $url, 'format' => $format, 'queryStr' => implode('&', $request));
break;
}
}
if (count($jsonRequests)) {
// perform social api requests
$request = new RemoteContentRequest('http://' . $_SERVER['HTTP_HOST'] . Config::get('web_prefix') . '/rpc?st=' . urlencode($securityToken) . '&format=json', "Content-Type: application/json\n", json_encode($jsonRequests));
$request->setMethod('POST');
$remoteFetcherClass = Config::get('remote_content_fetcher');
$remoteFetcher = new $remoteFetcherClass();
$basicRemoteContent = new BasicRemoteContent($remoteFetcher);
$response = $basicRemoteContent->fetch($request);
$decodedResponse = json_decode($response->getResponseContent(), true);
}
if (count($httpRequests)) {
$requestQueue = array();
foreach ($httpRequests as $request) {
$req = new RemoteContentRequest($_SERVER['HTTP_HOST'] . Config::get('web_prefix') . '/gadgets/makeRequest?url=' . urlencode($request['url']) . '&st=' . urlencode($securityToken) . (!empty($request['queryStr']) ? '&' . $request['queryStr'] : ''));
$req->getOptions()->ignoreCache = $context->getIgnoreCache();
$req->setNotSignedUri($request['url']);
$requestQueue[] = $req;
}
$basicRemoteContent = new BasicRemoteContent();
$resps = $basicRemoteContent->multiFetch($requestQueue);
foreach ($resps as $response) {
//FIXME: this isn't completely correct yet since this picks up the status code and headers
// as they are returned by the makeRequest handler and not the ones from the original request
$url = $response->getNotSignedUrl();
$id = $httpRequests[$url]['id'];
// strip out the UNPARSEABLE_CRUFT (see makeRequestHandler.php) on assigning the body
$resp = json_decode(str_replace("throw 1; < don't be evil' >", '', $response->getResponseContent()), true);
if (is_array($resp)) {
$statusCode = $response->getHttpCode();
$statusCodeMessage = $response->getHttpCodeMsg();
$headers = $response->getHeaders();
if (intval($statusCode) == 200) {
$content = $httpRequests[$url]['format'] == 'json' ? json_decode($resp[$url]['body'], true) : $resp[$url]['body'];
$toAdd = array('result' => array('content' => $content, 'status' => $statusCode, 'headers' => $headers));
} else {
$content = $resp[$url]['body'];
$toAdd = array('error' => array('code' => $statusCode, 'message' => $statusCodeMessage, 'result' => array('content' => $content, 'headers' => $headers)));
}
//$toAdd[$id] = array('id' => $id, 'result' => $httpRequests[$url]['format'] == 'json' ? json_decode($resp[$url]['body'], true) : $resp[$url]['body']);
$decodedResponse[] = array('id' => $id, 'result' => $toAdd);
}
}
}
return $decodedResponse;
}
/**
* Fetches the remote media content and saves it as a temporary file. Returns the meta data of the file.
*/
private function processRemoteContent($uri)
{
$request = new RemoteContentRequest($uri);
$request->createRemoteContentRequestWithUri($uri);
$brc = new BasicRemoteContent();
$response = $brc->fetch($request);
if ($response->getHttpCode() != 200) {
throw new SocialSpiException("Failed to fetch the content from {$uri} code: " . $response->getHttpCode(), ResponseError::$BAD_REQUEST);
}
if (!$this->isValidContentType($response->getContentType())) {
throw new SocialSpiException("The content type " . $response->getContentType() . " fetched from {$uri} is not valid.", ResponseError::$BAD_REQUEST);
}
return $this->writeBinaryContent($response->getResponseContent(), $response->getContentType());
}
/**
* Tests BasicRemoteContent->invalidate()
*/
public function testInvalidate()
{
// Fetches url for the first time.
$request = new RemoteContentRequest('http://test.chabotc.com/ok.html');
$ret = $this->basicRemoteContent->fetch($request);
$this->fetcher->clean();
$content = $ret->getResponseContent();
$this->assertEquals("OK", trim($content));
// Fetches url again and $this->fetcher->fetchRequest will not be called.
$request = new RemoteContentRequest('http://test.chabotc.com/ok.html');
$ret = $this->basicRemoteContent->fetch($request);
$this->assertTrue($this->fetcher->verify());
$content = $ret->getResponseContent();
$this->assertEquals("OK", trim($content));
// Invalidates cache and fetches url.
// $this->fetcher->fetchRequest will be called.
$request = new RemoteContentRequest('http://test.chabotc.com/ok.html');
$this->fetcher->expectFetchRequest($request);
$this->basicRemoteContent->invalidate($request);
$ret = $this->basicRemoteContent->fetch($request);
$this->assertTrue($this->fetcher->verify());
$content = $ret->getResponseContent();
$this->assertEquals("OK", trim($content));
}
/**
* Renders a 'proxied content' view, for reference see:
* http://opensocial-resources.googlecode.com/svn/spec/draft/OpenSocial-Data-Pipelining.xml
*
* @param Gadget $gadget
* @param array $view
*/
public function renderGadget(Shindig_Gadget $gadget, $view)
{
$this->setGadget($gadget);
if (Shindig_Config::get('P3P') != '') {
header("P3P: " . Shindig_Config::get('P3P'));
}
/* TODO
* We should really re-add OAuth fetching support some day, uses these view atributes:
* $view['oauthServiceName'], $view['oauthTokenName'], $view['oauthRequestToken'], $view['oauthRequestTokenSecret'];
*/
$authz = $this->getAuthz($view);
$refreshInterval = $this->getRefreshInterval($view);
$href = $this->buildHref($view, $authz);
if (count($view['dataPipelining'])) {
$request = new RemoteContentRequest($href, "Content-type: application/json\n");
$request->setMethod('POST');
$request->getOptions()->ignoreCache = $gadget->gadgetContext->getIgnoreCache();
} else {
// no data-pipelining set, use GET and set cache/refresh interval options
$request = new RemoteContentRequest($href);
$request->setMethod('GET');
$request->setRefreshInterval($refreshInterval);
$request->getOptions()->ignoreCache = $gadget->gadgetContext->getIgnoreCache();
}
$signingFetcherFactory = $gadgetSigner = false;
if ($authz != 'none') {
$gadgetSigner = Shindig_Config::get('security_token_signer');
$gadgetSigner = new $gadgetSigner();
$token = $gadget->gadgetContext->extractAndValidateToken($gadgetSigner);
$request->setToken($token);
$request->setAuthType($authz);
$request->getOptions()->ownerSigned = $this->getSignOwner($view);
$request->getOptions()->viewerSigned = $this->getSignViewer($view);
$signingFetcherFactory = new SigningFetcherFactory(Shindig_Config::get("private_key_file"));
}
$remoteFetcherClass = Shindig_Config::get('remote_content_fetcher');
$remoteFetcher = new $remoteFetcherClass();
$basicRemoteContent = new BasicRemoteContent($remoteFetcher, $signingFetcherFactory, $gadgetSigner);
// Cache POST's as if they were GET's, since we don't want to re-fetch and repost the social data for each view
$basicRemoteContent->setCachePostRequest(true);
if (($response = $basicRemoteContent->getCachedRequest($request)) == false) {
// Don't fetch the data-pipelining social data unless we don't have a cached version of the gadget's content
$dataPipeliningResults = DataPipelining::fetch($view['dataPipelining'], $this->context);
// spec stats that the proxied content data-pipelinging data is *not* available to templates (to avoid duplicate posting
// of the data to the gadget dev's server and once to js space), so we don't assign it to the data context, and just
// post the json encoded results to the remote url.
$request->setPostBody(json_encode($dataPipeliningResults));
$response = $basicRemoteContent->fetch($request);
}
if ($response->getHttpCode() != '200') {
// an error occured fetching the proxied content's gadget content
$content = '<html><body><h1>An error occured fetching the gadget content</h1><p>http error code: ' . $response->getHttpCode() . '</p><p>' . $response->getResponseContent() . '</body></html>';
} else {
// fetched ok, build the response document and output it
$content = $response->getResponseContent();
$content = $this->parseTemplates($content);
$content = $this->rewriteContent($content);
$content = $this->addTemplates($content);
}
echo $content;
}
/**
* Appends data from <Preload> elements to make them available to
* gadgets.io.
*
* @param gadget
*/
private function appendPreloads(Gadget $gadget, GadgetContext $context)
{
$resp = '';
$gadgetSigner = Config::get('security_token_signer');
$gadgetSigner = new $gadgetSigner();
$token = '';
try {
$token = $context->extractAndValidateToken($gadgetSigner);
} catch (Exception $e) {
$token = '';
// no token given, safe to ignore
}
foreach ($gadget->getPreloads() as $preload) {
try {
if (($preload->getAuth() == Auth::$NONE || $token != null) && (count($preload->getViews()) == 0 || in_array($context->getView(), $preload->getViews()))) {
$request = new RemoteContentRequest($preload->getHref());
$request->createRemoteContentRequestWithUri($preload->getHref());
$request->getOptions()->ownerSigned = $preload->isSignOwner();
$request->getOptions()->viewerSigned = $preload->isSignViewer();
switch (strtoupper(trim($preload->getAuth()))) {
case "NONE":
$brc = new BasicRemoteContent();
$response = $brc->fetch($request, $context);
break;
case "SIGNED":
$signingFetcherFactory = new SigningFetcherFactory(Config::get("private_key_file"));
$fetcher = $signingFetcherFactory->getSigningFetcher(new BasicRemoteContentFetcher(), $token);
$response = $fetcher->fetch($preload->getHref(), $request->getMethod());
break;
default:
@ob_end_clean();
header("HTTP/1.0 500 Internal Server Error", true);
echo "<html><body><h1>" . "500 - Internal Server Error" . "</h1></body></html>";
die;
}
$resp[$preload->getHref()] = array('body' => $response->getResponseContent(), 'rc' => $response->getHttpCode());
}
} catch (Exception $e) {
throw new Exception($e);
}
}
$resp = count($resp) ? json_encode($resp) : "{}";
return "gadgets.io.preloaded_ = " . $resp . ";\n";
}
