/**
* Render a PSR-7 request.
*
* @param RequestInterface $request
* @return string
*/
public function renderRequest(RequestInterface $request)
{
$return = '';
$return .= sprintf("URL: %s\n", $request->getUri());
$return .= sprintf("METHOD: %s\n", $request->getMethod());
if ($request->getHeaders()) {
$return .= 'HEADERS:';
}
$indent = false;
foreach ($request->getHeaders() as $name => $values) {
if ($indent) {
$return .= str_repeat(' ', 8);
}
$return .= sprintf(" %s: %s\n", $name, implode(', ', $values));
$indent = true;
}
if ($body = (string) $request->getBody()) {
$return .= 'BODY: ';
switch ($request->getHeaderLine('Content-Type')) {
case 'application/json':
$return .= json_encode(json_decode($body, true), JSON_PRETTY_PRINT);
break;
default:
$return .= $body;
break;
}
$return .= "\n";
}
return $return;
}
/**
* @param Request $request
*
* @return Response
*/
public function __invoke(Request $request)
{
$options = [];
// Headers
$headerLines = [];
foreach ($request->getHeaders() as $name => $values) {
$headerLines[] = sprintf('%s: %s', $name, implode(', ', $values));
}
$options[CURLOPT_HTTPHEADER] = $headerLines;
// Url
$options[CURLOPT_URL] = (string) $request->getUri();
switch ($request->getMethod()) {
case 'HEAD':
$options[CURLOPT_NOBODY] = true;
break;
case 'GET':
$options[CURLOPT_HTTPGET] = true;
break;
case 'POST':
$options[CURLOPT_POST] = true;
$options[CURLOPT_POSTFIELDS] = (string) $request->getBody();
// Don't duplicate the Content-Length header
$request = $request->withoutHeader('Content-Length');
$request = $request->withoutHeader('Transfer-Encoding');
break;
case 'PUT':
// Write to memory/temp
$file = fopen('php://temp/' . spl_object_hash($request), 'w+');
$bytes = fwrite($file, (string) $request->getBody());
rewind($file);
$options[CURLOPT_PUT] = true;
$options[CURLOPT_INFILE] = $file;
$options[CURLOPT_INFILESIZE] = $bytes;
$request = $request->withoutHeader('Content-Length');
break;
default:
$options[CURLOPT_CUSTOMREQUEST] = $request->getMethod();
}
// If the Expect header is not present, prevent curl from adding it
if (!$request->hasHeader('Expect')) {
$options[CURLOPT_HTTPHEADER][] = 'Expect:';
}
// cURL sometimes adds a content-type by default. Prevent this.
if (!$request->hasHeader('Content-Type')) {
$options[CURLOPT_HTTPHEADER][] = 'Content-Type:';
}
list($body, $headerLines) = $this->execute($options);
$headerLines = preg_split("#\r\n#", $headerLines, -1, PREG_SPLIT_NO_EMPTY);
$headers = [];
// Extract the version and status from the first header
preg_match('#HTTP/(\\d\\.\\d)\\s(\\d\\d\\d)\\s(.*)#', array_shift($headerLines), $matches);
array_shift($matches);
list($protocolVersion, $statusCode, $reasonPhrase) = $matches;
foreach ($headerLines as $line) {
list($name, $values) = preg_split('#\\s*:\\s*#', $line, 2, PREG_SPLIT_NO_EMPTY);
$headers[$name] = preg_split('#\\s*,\\s*#', $values, -1, PREG_SPLIT_NO_EMPTY);
}
$response = new \GuzzleHttp\Psr7\Response($statusCode, $headers, $body, $protocolVersion, $reasonPhrase);
return $response;
}
function it_returns_body_with_headers(RequestInterface $request, Stream $stream)
{
$request->getHeaders()->shouldBeCalled()->willReturn(['content-type' => 'application/json']);
$request->getBody()->shouldBeCalled()->willReturn($stream);
$stream->getContents()->shouldBeCalled()->willReturn('{"data": {}}');
$this->getBodyWithHeaders($request)->shouldReturn('content-type: application/json' . PHP_EOL . PHP_EOL . '{"data": {}}');
}
/**
* {@inheritdoc}
*/
public function request(RequestInterface $request)
{
$url = (string) $request->getUri();
$body = $request->getBody();
$body->seek(0);
$headers = $request->getHeaders();
$headers['Accept'] = 'application/json';
$headers['Content-Type'] = 'application/json';
$req = $this->guzzle->createRequest($request->getMethod(), $url);
$req->setHeaders($headers);
$req->setBody(GStream::factory($body->getContents()));
try {
$res = $this->guzzle->send($req);
} catch (RequestException $e) {
// Guzzle will throw exceptions for 4xx and 5xx responses, so we catch
// them here and quietly get the response object.
$res = $e->getResponse();
if (!$res) {
throw $e;
}
}
$response = (new Response(new Stream('php://memory', 'w')))->withStatus($res->getStatusCode(), $res->getReasonPhrase());
$response->getBody()->write((string) $res->getBody());
return $response;
}
/**
* Assert request matches against declared specification.
*
* The list of constraints:
*
* - Assert request method defined
* - Assert request URI declared by host, basePath, schemes and parameters (path, query)
* - Assert content-type declared by consumes
* - Assert headers declared by parameters (header)
* - Assert body declared by parameters (body)
*
* @param Spec $spec
* @param string $template
* @param Request $request
* @param string $msg
*/
protected static final function assertRequest(Spec $spec, $template, Request $request, $msg = '')
{
self::assertMethodAllowed($spec, $template, $request->getMethod(), $msg);
self::assertUri($spec, $template, $request->getMethod(), $request->getUri(), $msg);
self::assertRequestHeaders($spec, $template, $request->getMethod(), $request->getHeaders(), $msg);
self::assertRequestBody($spec, $template, $request->getMethod(), $request->getBody(), $msg);
}
/**
* @param RequestInterface $request
* @return ResponseInterface
*/
public function send($request)
{
/**
* var \GuzzleHttp\Message\Response $response
*/
$headers = $request->getHeaders();
if (!empty($this->append_headers)) {
$headers = array_merge($headers, $this->append_headers);
}
$opt = [];
if (!empty($this->basicAuth)) {
$opt['auth'] = $this->basicAuth;
}
if (!empty($headers)) {
$opt['headers'] = $headers;
}
$body = $request->getBody();
if ($body !== null) {
$opt['body'] = $body;
}
$g4request = $this->getClient()->createRequest($request->getMethod(), $request->getUri(), $opt);
try {
$response = $this->getClient()->send($g4request);
return new Response($response->getStatusCode(), $response->getHeaders(), $response->getBody());
} catch (\GuzzleHttp\Exception\RequestException $ex) {
$ex_request = $ex->getRequest();
$ex_response = $ex->getResponse();
throw new RequestException($ex->getMessage(), $ex_request ? new Request($ex_request->getMethod(), $ex_request->getUrl(), $ex_request->getHeaders(), $ex_request->getBody()) : null, $ex_response ? new Response($ex_response->getStatusCode(), $ex_response->getHeaders(), $ex_response->getBody()) : null, $ex);
}
}
public function detect()
{
if ($this->detected === null) {
$headers = $this->request->getHeaders();
$userAgent = $this->request->getHeaderLine('user-agent');
if ($this->detector->isMobile($headers, $userAgent)) {
$this->detected = 'mobile';
} else {
if ($this->detector->isTablet($headers, $userAgent)) {
$this->detected = 'tablet';
} else {
$this->detected = 'desktop';
}
}
}
return $this->detected;
}
/**
* @param RequestInterface $request
* @return string[]
*/
protected function getRequestHeaders(RequestInterface $request)
{
$headers = array();
foreach (array_keys($request->getHeaders()) as $name) {
$headers[] = $name . ': ' . $request->getHeaderLine($name);
}
return $headers;
}
/**
* @return HttpRequest mixed
*/
protected function setupRequest()
{
$headers = [];
foreach ($this->request->getHeaders() as $key => $values) {
$headers[$key] = implode(';', $values);
}
return $this->httpClient->request($this->request->getMethod(), (string) $this->request->getUri(), $headers, $this->request->getProtocolVersion());
}
/**
* {@inheritdoc}
*/
public function formatRequest(RequestInterface $request)
{
$message = sprintf("%s %s HTTP/%s\n", $request->getMethod(), $request->getRequestTarget(), $request->getProtocolVersion());
foreach ($request->getHeaders() as $name => $values) {
$message .= $name . ': ' . implode(', ', $values) . "\n";
}
return $this->addBody($request, $message);
}
/**
* Converts a PSR request into a Guzzle request.
*
* @param RequestInterface $request
*
* @return GuzzleRequest
*/
private function createRequest(RequestInterface $request)
{
$options = ['exceptions' => false, 'allow_redirects' => false];
$options['version'] = $request->getProtocolVersion();
$options['headers'] = $request->getHeaders();
$options['body'] = (string) $request->getBody();
return $this->client->createRequest($request->getMethod(), (string) $request->getUri(), $options);
}
/**
* Generates headers for given request
* @param RequestInterface $request
* @return array
*/
public function generate(RequestInterface $request)
{
$headers = [];
foreach ($request->getHeaders() as $name => $values) {
$headers[] = sprintf('%s: %s', $name, implode(', ', $values));
}
$headers[] = self::CHUNKED_TRANSFER_HEADER;
return $headers;
}
public function sign(RequestInterface $request, $key, $secret, $customerId = null)
{
$nonce = $this->nonceGenerator->generateNonce();
$signature = hash_hmac('sha256', $nonce . $customerId . $key, $secret);
parse_str($request->getBody()->getContents(), $params);
$params = array_merge(['key' => $key, 'nonce' => $nonce, 'signature' => $signature], $params);
$body = http_build_query($params);
return new Request($request->getMethod(), $request->getUri(), $request->getHeaders(), $body);
}
public static function request(RequestInterface $request)
{
$method = $request->getMethod();
$url = $request->getUri();
$body = $request->getBody()->getContents();
$headers = $request->getHeaders();
$protocolVersion = $request->getProtocolVersion();
return new HttpObservable($method, $url, $body, $headers, $protocolVersion);
}
/**
* Produce the header of request as a string based on a PSR Request
*
* @param RequestInterface $request
*
* @return string
*/
protected function transformRequestHeadersToString(RequestInterface $request)
{
$message = vsprintf('%s %s HTTP/%s', [strtoupper($request->getMethod()), $request->getRequestTarget(), $request->getProtocolVersion()]) . "\r\n";
foreach ($request->getHeaders() as $name => $values) {
$message .= $name . ': ' . implode(', ', $values) . "\r\n";
}
$message .= "\r\n";
return $message;
}
function get_headers(RequestInterface $request)
{
$headers = array();
foreach ($request->getHeaders() as $name => $values) {
foreach ($values as $value) {
$headers[] = sprintf('%s: %s', $name, $value);
}
}
return $headers;
}
/**
* Assigns options specific to handling HTTP requests.
* NOTE: THIS METHOD SHOULD BE CALLED ONLY FROM prepareCUrl()!
*
* @throws UnsupportedFeatureException Thrown if POST method was requested.
*/
private function prepareHttpCUrl()
{
if ($this->fetchRequest->getMethod() !== 'GET') {
throw new UnsupportedFeatureException('Request other than GET are not supported');
}
$headers = [];
foreach ($this->fetchRequest->getHeaders() as $name => $values) {
$headers[] = $name . ": " . implode(", ", $values);
}
curl_setopt_array($this->cUrl, [CURLOPT_AUTOREFERER => 1, CURLOPT_FOLLOWLOCATION => 1, CURLOPT_FAILONERROR => 1, CURLOPT_HTTP_VERSION => $this->fetchRequest->getProtocolVersion() === '1.0' ? CURL_HTTP_VERSION_1_0 : CURL_HTTP_VERSION_1_1, CURLOPT_USERAGENT => $this->fetchRequest->getHeader('User-Agent') ?: $this->getDefaultUserAgent(), CURLOPT_HTTPHEADER => $headers]);
}
protected function getFileName(RequestInterface $request)
{
$result = trim($request->getMethod() . ' ' . $request->getRequestTarget()) . ' HTTP/' . $request->getProtocolVersion();
foreach ($request->getHeaders() as $name => $values) {
if (array_key_exists(strtoupper($name), $this->ignored_headers)) {
continue;
}
$result .= "\r\n{$name}: " . implode(', ', $values);
}
$request = $result . "\r\n\r\n" . $request->getBody();
return md5((string) $request) . ".txt";
}
/**
* Create a fingerprint for each request.
*
* As it is for mocking (and not for real caching), ignore some
* characteristics like the 'User-Agent' to avoid stale cache
* when updating PHP or Guzzle.
*
* @param RequestInterface $request
*
* @return string The path to the mock file
*/
public function getPath(RequestInterface $request)
{
$headers = $request->getHeaders();
foreach ($headers as $name => $values) {
if (in_array($name, $this->headersBlacklist)) {
unset($headers[$name]);
}
}
$fingerprint = md5(serialize(['method' => $request->getMethod(), 'path' => $request->getUri()->getPath(), 'query' => $request->getUri()->getQuery(), 'user_info' => $request->getUri()->getUserInfo(), 'port' => $request->getUri()->getPort(), 'scheme' => $request->getUri()->getScheme(), 'headers' => $headers]));
$path = sprintf('%s_%s____%s', str_pad($request->getMethod(), 6, '_'), urldecode(ltrim($request->getUri()->getPath(), '/') . '-' . $request->getUri()->getQuery()), $fingerprint);
return $this->storagePath . '/' . preg_replace('/[^a-zA-Z0-9_+=@\\-\\?\\.]/', '-', $path) . '.txt';
}
/**
* @param RequestInterface $request
* @param string $type
*/
protected function logRequest(RequestInterface $request, $type = 'http')
{
$args = [ucfirst($type), $request->getMethod(), $request->getUri()];
/** @noinspection PrintfScanfArgumentsInspection */
$this->log(sprintf(' ==> (%s) %s %s', ...$args));
$headers = $this->removeTokenFromLogs($request->getHeaders());
$this->log(' Request headers: ' . json_encode($headers), Logger::DEBUG);
$size = strlen($request->getBody());
if ($size > 0) {
$this->log(sprintf(' Request body (%sb): %s', $size, $request->getBody()), Logger::DEBUG);
}
}
/**
* Serialize a request message to a string.
*
* @param RequestInterface $request
* @return string
*/
public static function toString(RequestInterface $request)
{
$headers = self::serializeHeaders($request->getHeaders());
$body = (string) $request->getBody();
$format = '%s %s HTTP/%s%s%s';
if (!empty($headers)) {
$headers = "\r\n" . $headers;
}
if (!empty($body)) {
$headers .= "\r\n\r\n";
}
return sprintf($format, $request->getMethod(), $request->getRequestTarget(), $request->getProtocolVersion(), $headers, $body);
}
/**
* @return Request
*/
protected function convertRequest(RequestInterface $request, array $options)
{
$artaxRequest = new Request();
$artaxRequest->setProtocol($request->getProtocolVersion());
$artaxRequest->setMethod($request->getMethod());
$artaxRequest->setUri((string) $request->getUri());
$artaxRequest->setAllHeaders($request->getHeaders());
$body = $request->getBody();
if ($body->getSize() === null || $body->getSize() > 0) {
$body->rewind();
$artaxRequest->setBody(new PsrStreamIterator($body));
}
return $artaxRequest;
}
/**
* @param RequestInterface $request
*
* @return string
*/
private function getHeadersAsCommandOptions(RequestInterface $request)
{
$command = '';
foreach ($request->getHeaders() as $name => $values) {
if ('host' === strtolower($name) && $values[0] === $request->getUri()->getHost()) {
continue;
}
if ('user-agent' === strtolower($name)) {
$command .= sprintf('-A %s', escapeshellarg($values[0]));
continue;
}
$command .= sprintf(' -H %s', escapeshellarg($name . ': ' . $request->getHeaderLine($name)));
}
return $command;
}
/**
* {@inheritdoc}
*/
public function request(RequestInterface $request)
{
$url = (string) $request->getUri();
$body = $request->getBody();
$body->seek(0);
$headers = $request->getHeaders();
foreach ($headers as $name => $value) {
$headers[$name] = implode(', ', $value);
}
$headers['Accept'] = 'application/json';
$headers['Content-Type'] = 'application/json';
$options = array('method' => $request->getMethod(), 'headers' => $headers, 'data' => $body->getContents());
$res = drupal_http_request($url, $options);
$response = (new Response(new Stream('php://memory', 'w')))->withStatus($res->code, $res->status_message);
$response->getBody()->write($res->data);
return $response;
}
/**
* Serialize a request message to a string.
*
* @param RequestInterface $request
* @return string
*/
public static function toString(RequestInterface $request)
{
$httpMethod = $request->getMethod();
if (empty($httpMethod)) {
throw new UnexpectedValueException('Object can not be serialized because HTTP method is empty');
}
$headers = self::serializeHeaders($request->getHeaders());
$body = (string) $request->getBody();
$format = '%s %s HTTP/%s%s%s';
if (!empty($headers)) {
$headers = "\r\n" . $headers;
}
if (!empty($body)) {
$headers .= "\r\n\r\n";
}
return sprintf($format, $httpMethod, $request->getRequestTarget(), $request->getProtocolVersion(), $headers, $body);
}
public function sendRequest(RequestInterface $request, ProxyInterface $proxy = null, CookieJarInterface $cookieJar = null)
{
$commandOptions = $this->phantomJsOptions;
if ($proxy) {
$proxyHost = $proxy->getHost() . ':' . $proxy->getPort();
$commandOptions[] = '--proxy=' . $proxyHost;
if ($user = $proxy->getUser()) {
$proxyAuth = $user;
if ($password = $proxy->getPassword()) {
$proxyAuth .= ':' . $password;
}
$commandOptions[] = '--proxy-auth=' . $proxyAuth;
}
if ($proxy->getType() == 'SOCKS5') {
$commandOptions[] = '--proxy-type=socks5';
} elseif ($proxy->getType() == 'SOCKS4') {
throw new Exception('SOCKS4 proxy are not supported by phantomjs');
}
}
$initialUrl = (string) $request->getUri();
$commandArg = ['method' => $request->getMethod(), 'url' => $initialUrl, 'headers' => []];
foreach ($request->getHeaders() as $headerName => $headerValues) {
$commandArg['headers'][$headerName] = implode(',', $headerValues);
}
$data = (string) $request->getBody();
if ($data) {
$commandArg['data'] = $data;
}
$scriptFile = __DIR__ . '/phantomjs.js';
$commandOptions = implode(' ', $commandOptions);
$commandArg = json_encode($commandArg);
$process = new Process("{$this->phantomJS} {$commandOptions} {$scriptFile} '{$commandArg}'");
$process->run();
if (!$process->isSuccessful()) {
throw new ProcessFailedException($process);
}
$dataResponse = json_decode($process->getOutput(), true);
if (!$dataResponse) {
throw new Exception('Unable to parse Phantomjs response: ' . json_last_error_msg());
}
$response = new SearchEngineResponse($dataResponse['headers'], $dataResponse['status'], $dataResponse['content'], true, UrlArchive::fromString($initialUrl), UrlArchive::fromString($dataResponse['url']), $proxy);
return $response;
}
/**
* Sends a PSR-7 request.
*
* @param RequestInterface $request
*
* @return ResponseInterface
*
* @throws \Http\Client\Exception If an error happens during processing the request.
* @throws \Exception If processing the request is impossible (eg. bad configuration).
*/
public function sendRequest(RequestInterface $request)
{
$body = (string) $request->getBody();
$headers = [];
foreach (array_keys($request->getHeaders()) as $headerName) {
if (strtolower($headerName) === 'content-length') {
$values = array(strlen($body));
} else {
$values = $request->getHeader($headerName);
}
foreach ($values as $value) {
$headers[] = $headerName . ': ' . $value;
}
}
$streamContextOptions = array('protocol_version' => $request->getProtocolVersion(), 'method' => $request->getMethod(), 'header' => implode("\r\n", $headers), 'timeout' => $this->timeout, 'ignore_errors' => true, 'follow_location' => $this->followRedirects ? 1 : 0, 'max_redirects' => 100);
if (strlen($body) > 0) {
$streamContextOptions['content'] = $body;
}
$context = stream_context_create(array('http' => $streamContextOptions, 'https' => $streamContextOptions));
$httpHeadersOffset = 0;
$finalUrl = (string) $request->getUri();
stream_context_set_params($context, array('notification' => function ($code, $severity, $msg, $msgCode, $bytesTx, $bytesMax) use(&$remoteDocument, &$http_response_header, &$httpHeadersOffset) {
if ($code === STREAM_NOTIFY_REDIRECTED) {
$finalUrl = $msg;
$httpHeadersOffset = count($http_response_header);
}
}));
$response = $this->messageFactory->createResponse();
if (false === ($responseBody = @file_get_contents((string) $request->getUri(), false, $context))) {
if (!isset($http_response_header)) {
throw new NetworkException('Unable to execute request', $request);
}
} else {
$response = $response->withBody($this->streamFactory->createStream($responseBody));
}
$parser = new HeaderParser();
try {
return $parser->parseArray(array_slice($http_response_header, $httpHeadersOffset), $response);
} catch (\Exception $e) {
throw new RequestException($e->getMessage(), $request, $e);
}
}
/**
* Prepare options
*
* @param RequestInterface $request
*/
protected function prepareOptions(RequestInterface $request)
{
$this->options[CURLOPT_URL] = (string) $request->getUri();
$this->options[CURLOPT_HTTP_VERSION] = $request->getProtocolVersion();
// Set request method
if (strtoupper($request->getMethod()) === 'GET') {
$this->options[CURLOPT_HTTPGET] = true;
} elseif (strtoupper($request->getMethod()) === 'HEAD') {
$this->options[CURLOPT_NOBODY] = true;
} else {
$this->options[CURLOPT_CUSTOMREQUEST] = $request->getMethod();
}
// Prepare and set request headers
foreach ($request->getHeaders() as $name => $values) {
foreach ($values as $value) {
$this->options[CURLOPT_HTTPHEADER][] = sprintf('%s: %s', $name, $value);
}
}
curl_setopt_array($this->handle, $this->options);
}
/**
* {@inheritdoc}
*/
public function sendRequest(RequestInterface $request)
{
$cakeRequest = new Request();
$cakeRequest->method($request->getMethod());
$cakeRequest->url((string) $request->getUri());
$cakeRequest->version($request->getProtocolVersion());
$cakeRequest->body($request->getBody()->getContents());
foreach ($request->getHeaders() as $header => $values) {
$cakeRequest->header($header, $request->getHeaderLine($header));
}
if (null === $cakeRequest->header('Content-Type')) {
$cakeRequest->header('Content-Type', 'application/x-www-form-urlencoded');
}
try {
$cakeResponse = $this->client->send($cakeRequest, $this->client->config());
} catch (Exception $exception) {
throw new NetworkException('Failed to send request', $request, $exception);
}
return $this->responseFactory->createResponse($cakeResponse->statusCode(), null, $cakeResponse->headers(), $cakeResponse->body(), $cakeResponse->version());
}
/**
* @param RequestInterface $request
* @return ResponseInterface
*/
public function send($request)
{
/**
* var Guzzle\Http\Message\Response $response
*/
$headers = $request->getHeaders();
if (!empty($this->append_headers)) {
$headers = array_merge($headers, $this->append_headers);
}
try {
$g3request = $this->getClient()->createRequest($request->getMethod(), $request->getUri(), $headers, $request->getBody());
$response = $g3request->send();
} catch (\Guzzle\Http\Exception\BadResponseException $ex) {
$ex_request = $ex->getRequest();
$ex_response = $ex->getResponse();
throw new RequestException($ex->getMessage(), $ex_request ? new Request($ex_request->getMethod(), $ex_request->getUrl(), $ex_request->getHeaders()->toArray(), $request->getBody()) : null, $ex_response ? new Response($ex_response->getStatusCode(), $ex_response->getHeaders()->toArray(), $ex_response->getBody()) : null, $ex);
} catch (\Guzzle\Http\Exception\RequestException $ex) {
$ex_request = $ex->getRequest();
throw new RequestException($ex->getMessage(), $ex_request ? new Request($ex_request->getMethod(), $ex_request->getUrl(), $ex_request->getHeaders()->toArray(), $request->getBody()) : null, null, $ex);
}
return new Response($response->getStatusCode(), $response->getHeaderLines(), $response->getBody());
}
