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