private function sendHeaders() { foreach ($this->response->getHeaders() as $name => $values) { foreach ($values as $value) { header($name . ': ' . $value); } } }
/** * @param ResponseInterface $response * * @return ApiResult */ protected function _getResult($response) { if (!$response instanceof ResponseInterface) { throw new \InvalidArgumentException("{$response} should be an instance of ResponseInterface"); } $result = new ApiResult(); $result->setStatusCode($response->getStatusCode()); $callId = $response->getHeader('X-Call-Id'); if (!empty($callId)) { $result->setCallId($callId); } $decoded = json_decode((string) $response->getBody()); if (isset($decoded->meta) && isset($decoded->data) && isset($decoded->meta->code) && $decoded->meta->code == $response->getStatusCode()) { $meta = $decoded->meta; $data = $decoded->data; if (isset($meta->message)) { $result->setStatusMessage($meta->message); } $result->setContent(json_encode($data)); } else { $result->setContent((string) $response->getBody()); } $result->setHeaders($response->getHeaders()); return $result; }
/** * @param ResponseInterface $response */ public function send(ResponseInterface $response) { /** * build response header */ foreach ($response->getHeaders() as $key => $value) { $filter_header = function ($header) { $filtered = str_replace('-', ' ', $header); $filtered = ucwords($filtered); return str_replace(' ', '-', $filtered); }; $name = $filter_header($key); foreach ($value as $v) { $this->app['SwooleResponder']->header($name, $v); } } /** * compress content */ if (!empty($this->app['Config']['server.gzip'])) { $this->app['SwooleResponder']->gzip($this->app['Config']['server.gzip']); } $this->app['SwooleResponder']->status($response->getStatusCode()); $this->app['SwooleResponder']->header('Server', 'vinnige-app-server'); $this->app['SwooleResponder']->end((string) $response->getBody()); }
/** * Stops the profiling. * @param ResponseInterface $response */ public function leave(ResponseInterface $response = null) { $this->ends = ['wt' => microtime(true), 'mu' => memory_get_usage(), 'pmu' => memory_get_peak_usage()]; if ($response) { $this->response = ['headers' => $response->getHeaders(), 'statusCode' => $response->getStatusCode(), 'body' => (string) $response->getBody()]; } }
/** * @param ResponseInterface $response * @param string $type */ protected function logResponse(ResponseInterface $response, $type = 'http') { $args = [ucfirst($type), $response->getStatusCode(), $response->getReasonPhrase()]; /** @noinspection PrintfScanfArgumentsInspection */ $this->log(sprintf(' <== (%s) %s %s', ...$args)); $headers = $this->removeTokenFromLogs($response->getHeaders()); $this->log(' Response headers: ' . json_encode($headers), Logger::DEBUG); }
/** * Convert the PSR-7 headers to string * * @param ResponseInterface $psr7Response * @return string */ private static function psr7HeadersToString(ResponseInterface $psr7Response) { $headers = ''; foreach ($psr7Response->getHeaders() as $name => $value) { $headers .= $name . ": " . implode(", ", $value) . "\r\n"; } return $headers; }
public function formatResponse(ResponseInterface $response) { $format = ['code' => $response->getStatusCode(), 'headers' => $response->getHeaders(), 'body' => (string) $response->getBody()]; if ($this->markerHeader) { $format['headers']['X-Guzzle-Stereo'] = true; } return $format; }
/** * {@inheritdoc} */ public function formatResponse(ResponseInterface $response) { $message = sprintf("HTTP/%s %s %s\n", $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase()); foreach ($response->getHeaders() as $name => $values) { $message .= $name . ': ' . implode(', ', $values) . "\n"; } return $this->addBody($response, $message); }
/** * Save data * * @author Florian Preusner * @version 2.1 * @since 2015-05 * * @param ResponseInterface $response */ public function save(ResponseInterface $response) { $this->setStatusCode($response->getStatusCode()); $this->setStatusPhrase($response->getReasonPhrase()); $this->setBody($response->getBody()->__toString()); $this->setHeaders($response->getHeaders()); $this->setProtocolVersion($response->getProtocolVersion()); }
/** * @param ResponseInterface $response */ public function send(ResponseInterface $response) { header('HTTP/' . $response->getProtocolVersion() . ' ' . $response->getStatusCode() . ' ' . $response->getReasonPhrase()); foreach ($response->getHeaders() as $header => $values) { header($header . ': ' . implode(', ', $values)); } parent::send($response); }
/** * Returns the Guzzle array of headers as a string. * * @param ResponseInterface $response The Guzzle response. * * @return string */ public function getHeadersAsString(ResponseInterface $response) { $headers = $response->getHeaders(); $rawHeaders = []; foreach ($headers as $name => $values) { $rawHeaders[] = $name . ": " . implode(", ", $values); } return implode("\r\n", $rawHeaders); }
/** * {@inheritdoc} */ public function createResponse(ResponseInterface $psrResponse) { $response = new Response($psrResponse->getBody()->__toString(), $psrResponse->getStatusCode(), $psrResponse->getHeaders()); $response->setProtocolVersion($psrResponse->getProtocolVersion()); foreach ($psrResponse->getHeader('Set-Cookie') as $cookie) { $response->headers->setCookie($this->createCookie($cookie)); } return $response; }
private function emitHeaders(ResponseInterface $response) { foreach ($response->getHeaders() as $header => $values) { $name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $header))); foreach ($values as $value) { $this->output->writeln(sprintf('%s: %s', $name, $value)); } } }
/** * Response constructor. * * @param ResponseInterface $response */ public function __construct($response) { if ($response instanceof ResponseInterface) { $this->statusCode = $response->getStatusCode(); $this->body = $response->getBody(); $this->headers = $response->getHeaders(); } $this->decodedBody = json_decode($this->body, true); }
/** * Constructs a representable document * * @param ResponseInterface $response */ public function __construct(ResponseInterface $response) { $headers = $response->getHeaders(); // What better to get the mime type than what the Telegram servers already send us? $this->mime_type = $headers['Content-Type'][0]; // Same with file length $this->file_size = (int) $headers['Content-Length'][0]; $this->contents = (string) $response->getBody(); }
/** * Send response to the client * * @return void */ protected function sendResponse() { http_response_code($this->response->getStatusCode()); foreach ($this->response->getHeaders() as $name => $values) { foreach ($values as $value) { header(sprintf('%s: %s', $name, $value), false); } } echo $this->response->getBody(); }
/** * Emit response headers. * * Loops through each header, emitting each; if the header value * is an array with multiple values, ensures that each is sent * in such a way as to create aggregate headers (instead of replace * the previous). * * @param ResponseInterface $response */ private function emitHeaders(ResponseInterface $response) { foreach ($response->getHeaders() as $header => $values) { $name = $this->filterHeader($header); foreach ($values as $value) { $header = sprintf("%s: %s\r\n", $name, $value); $this->conn->write($header); } } }
/** * Sends the response headers. * * @param \Psr\Http\Message\ResponseInterface $response Response instance */ private function sendHeaders(ResponseInterface $response) { $statusCode = $response->getStatusCode(); header(sprintf('HTTP/%s %d %s', $response->getProtocolVersion(), $statusCode, $response->getReasonPhrase()), true, $statusCode); foreach ($response->getHeaders() as $name => $values) { foreach ($values as $value) { header("{$name}: {$value}", false, $statusCode); } } }
public function send(ResponseInterface $response) { http_response_code($response->getStatusCode()); foreach ($response->getHeaders() as $header => $values) { foreach ($values as $value) { header($header . ':' . $value, false); } } Psr7\copy_to_stream($response->getBody(), $this->environment->getStdOut()); }
/** * Asserts response match with the response schema. * * @param ResponseInterface $response * @param SchemaManager $schemaManager * @param string $path percent-encoded path used on the request. * @param string $httpMethod * @param string $message */ public function assertResponseMatch(ResponseInterface $response, SchemaManager $schemaManager, $path, $httpMethod, $message = '') { $this->assertResponseMediaTypeMatch($response->getHeaderLine('Content-Type'), $schemaManager, $path, $httpMethod, $message); $httpCode = $response->getStatusCode(); $headers = $response->getHeaders(); foreach ($headers as &$value) { $value = implode(', ', $value); } $this->assertResponseHeadersMatch($headers, $schemaManager, $path, $httpMethod, $httpCode, $message); $this->assertResponseBodyMatch(json_decode($response->getBody()), $schemaManager, $path, $httpMethod, $httpCode, $message); }
public function sendResponse(ResponseInterface $response) { $headers = []; foreach ($response->getHeaders() as $name => $values) { $headers[$name] = implode(', ', $values); } $response->getBody()->rewind(); $size = $response->getBody()->getSize(); $this->writeHead($size > 0, $response->getStatusCode(), $response->getReasonPhrase(), $headers); $this->end($response->getBody()->getContents()); }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable|null $next * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null) { $rowset = $request->getAttribute('Response-Body'); $status = $response->getStatusCode(); $headers = $response->getHeaders(); $response = new JsonResponse($rowset, $status, $headers); if ($next) { return $next($request, $response); } return $response; }
public function parseMetadata(ResponseInterface $response) : array { $metadata = []; foreach ($response->getHeaders() as $header => $value) { $position = strpos($header, static::METADATA_PREFIX); if ($position === 0) { $metadata[ltrim($header, static::METADATA_PREFIX)] = $response->getHeader($header)[0]; } } return $metadata; }
/** * Emit response headers. * * Loops through each header, emitting each; if the header value * is an array with multiple values, ensures that each is sent * in such a way as to create aggregate headers (instead of replace * the previous). * * @param ResponseInterface $response */ private function emitHeaders(ResponseInterface $response) { foreach ($response->getHeaders() as $header => $values) { $name = $this->filterHeader($header); $first = true; foreach ($values as $value) { header(sprintf('%s: %s', $name, $value), $first); $first = false; } } }
/** * Convert a PSR7 Response headers into a flat array * * @param PsrResponse $response The response to convert. * @return CakeResponse The equivalent CakePHP response */ protected static function collapseHeaders(PsrResponse $response) { $out = []; foreach ($response->getHeaders() as $name => $value) { if (count($value) === 1) { $out[$name] = $value[0]; } else { $out[$name] = $value; } } return $out; }
/** * Create a string representation of a response. * * @param ResponseInterface $response * @return string */ public static function toString(ResponseInterface $response) { $reasonPhrase = $response->getReasonPhrase(); $headers = self::serializeHeaders($response->getHeaders()); $body = (string) $response->getBody(); $format = 'HTTP/%s %d%s%s%s'; if (!empty($headers)) { $headers = "\r\n" . $headers; } $headers .= "\r\n\r\n"; return sprintf($format, $response->getProtocolVersion(), $response->getStatusCode(), $reasonPhrase ? ' ' . $reasonPhrase : '', $headers, $body); }
/** * @param RequestInterface $request * @param ResponseInterface $response * @throws ValidatorResponseException */ private function assertNoMissingHeaders(RequestInterface $request, ResponseInterface $response) { $method = $request->getMethod(); $path = $request->getUri()->getPath(); $statusCode = $response->getStatusCode(); $schemaHeaders = $this->schemaHelper->getResponseHeaders($method, $path, $statusCode, true); $missingHeaders = array_diff_key($schemaHeaders, $response->getHeaders()); if (count($missingHeaders) === 0) { return; } throw new ValidatorResponseException(sprintf('Missing response headers required by the schema for %s %s with status code %s: %s', strtoupper($method), $path, $statusCode, $this->getNamedParametersAsString($missingHeaders))); }
/** * Process a ResponseInterface into an output. * * @param ResponseInterface $httpResponse */ public function execute(ResponseInterface $httpResponse) { $headerFunction = $this->headerFunction; $bodyFunction = $this->bodyFunction; $headerFunction('HTTP/' . $httpResponse->getProtocolVersion() . ' ' . $httpResponse->getStatusCode() . ' ' . $httpResponse->getReasonPhrase()); foreach ($httpResponse->getHeaders() as $name => $values) { foreach ($values as $value) { $headerFunction(sprintf('%s: %s', $name, $value)); } } $bodyFunction($httpResponse->getBody()); }
public static function sendResponse(Response $response) { header(sprintf('HTTP/%s %s %s', $response->getProtocolVersion(), $response->getStatusCode(), $response->getReasonPhrase())); foreach ($response->getHeaders() as $name => $values) { foreach ($values as $value) { header(sprintf('%s: %s', $name, $value), false); } } if (!in_array($response->getStatusCode(), [204, 205, 304])) { echo $response->getBody(); } }
/** * Outputs content if there is a proper Response object. * * @return Bootstrap */ protected function sendResponse() { if ($this->response instanceof \Psr\Http\Message\ResponseInterface) { if (!headers_sent()) { foreach ($this->response->getHeaders() as $name => $values) { header($name . ': ' . implode(', ', $values), FALSE); } } echo $this->response->getBody()->__toString(); } return $this; }