class ServerRequest in Lockr 7.3

Server-side HTTP request

Extends the Request definition to add methods for accessing incoming data, specifically server parameters, cookies, matched path parameters, query string arguments, body parameters, and upload file information.

"Attributes" are discovered via decomposing the request (and usually specifically the URI path), and typically will be injected by the application.

Requests are considered immutable; all methods that might change state are implemented such that they retain the internal state of the current message and return a new instance that contains the changed state.

Hierarchy

class \GuzzleHttp\Psr7\Request implements RequestInterface uses MessageTrait
- class \GuzzleHttp\Psr7\ServerRequest implements ServerRequestInterface

Expanded class hierarchy of ServerRequest

File

vendor/guzzlehttp/psr7/src/ServerRequest.php, line 25

Namespace

GuzzleHttp\Psr7

View source

class ServerRequest extends Request implements ServerRequestInterface {

  /**
   * @var array
   */
  private $attributes = [];

  /**
   * @var array
   */
  private $cookieParams = [];

  /**
   * @var null|array|object
   */
  private $parsedBody;

  /**
   * @var array
   */
  private $queryParams = [];

  /**
   * @var array
   */
  private $serverParams;

  /**
   * @var array
   */
  private $uploadedFiles = [];

  /**
   * @param string                               $method       HTTP method
   * @param string|UriInterface                  $uri          URI
   * @param array                                $headers      Request headers
   * @param string|null|resource|StreamInterface $body         Request body
   * @param string                               $version      Protocol version
   * @param array                                $serverParams Typically the $_SERVER superglobal
   */
  public function __construct($method, $uri, array $headers = [], $body = null, $version = '1.1', array $serverParams = []) {
    $this->serverParams = $serverParams;
    parent::__construct($method, $uri, $headers, $body, $version);
  }

  /**
   * Return an UploadedFile instance array.
   *
   * @param array $files A array which respect $_FILES structure
   * @throws InvalidArgumentException for unrecognized values
   * @return array
   */
  public static function normalizeFiles(array $files) {
    $normalized = [];
    foreach ($files as $key => $value) {
      if ($value instanceof UploadedFileInterface) {
        $normalized[$key] = $value;
      }
      elseif (is_array($value) && isset($value['tmp_name'])) {
        $normalized[$key] = self::createUploadedFileFromSpec($value);
      }
      elseif (is_array($value)) {
        $normalized[$key] = self::normalizeFiles($value);
        continue;
      }
      else {
        throw new InvalidArgumentException('Invalid value in files specification');
      }
    }
    return $normalized;
  }

  /**
   * Create and return an UploadedFile instance from a $_FILES specification.
   *
   * If the specification represents an array of values, this method will
   * delegate to normalizeNestedFileSpec() and return that return value.
   *
   * @param array $value $_FILES struct
   * @return array|UploadedFileInterface
   */
  private static function createUploadedFileFromSpec(array $value) {
    if (is_array($value['tmp_name'])) {
      return self::normalizeNestedFileSpec($value);
    }
    return new UploadedFile($value['tmp_name'], (int) $value['size'], (int) $value['error'], $value['name'], $value['type']);
  }

  /**
   * Normalize an array of file specifications.
   *
   * Loops through all nested files and returns a normalized array of
   * UploadedFileInterface instances.
   *
   * @param array $files
   * @return UploadedFileInterface[]
   */
  private static function normalizeNestedFileSpec(array $files = []) {
    $normalizedFiles = [];
    foreach (array_keys($files['tmp_name']) as $key) {
      $spec = [
        'tmp_name' => $files['tmp_name'][$key],
        'size' => $files['size'][$key],
        'error' => $files['error'][$key],
        'name' => $files['name'][$key],
        'type' => $files['type'][$key],
      ];
      $normalizedFiles[$key] = self::createUploadedFileFromSpec($spec);
    }
    return $normalizedFiles;
  }

  /**
   * Return a ServerRequest populated with superglobals:
   * $_GET
   * $_POST
   * $_COOKIE
   * $_FILES
   * $_SERVER
   *
   * @return ServerRequestInterface
   */
  public static function fromGlobals() {
    $method = isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : 'GET';
    $headers = getallheaders();
    $uri = self::getUriFromGlobals();
    $body = new LazyOpenStream('php://input', 'r+');
    $protocol = isset($_SERVER['SERVER_PROTOCOL']) ? str_replace('HTTP/', '', $_SERVER['SERVER_PROTOCOL']) : '1.1';
    $serverRequest = new ServerRequest($method, $uri, $headers, $body, $protocol, $_SERVER);
    return $serverRequest
      ->withCookieParams($_COOKIE)
      ->withQueryParams($_GET)
      ->withParsedBody($_POST)
      ->withUploadedFiles(self::normalizeFiles($_FILES));
  }
  private static function extractHostAndPortFromAuthority($authority) {
    $uri = 'http://' . $authority;
    $parts = parse_url($uri);
    if (false === $parts) {
      return [
        null,
        null,
      ];
    }
    $host = isset($parts['host']) ? $parts['host'] : null;
    $port = isset($parts['port']) ? $parts['port'] : null;
    return [
      $host,
      $port,
    ];
  }

  /**
   * Get a Uri populated with values from $_SERVER.
   *
   * @return UriInterface
   */
  public static function getUriFromGlobals() {
    $uri = new Uri('');
    $uri = $uri
      ->withScheme(!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' ? 'https' : 'http');
    $hasPort = false;
    if (isset($_SERVER['HTTP_HOST'])) {
      list($host, $port) = self::extractHostAndPortFromAuthority($_SERVER['HTTP_HOST']);
      if ($host !== null) {
        $uri = $uri
          ->withHost($host);
      }
      if ($port !== null) {
        $hasPort = true;
        $uri = $uri
          ->withPort($port);
      }
    }
    elseif (isset($_SERVER['SERVER_NAME'])) {
      $uri = $uri
        ->withHost($_SERVER['SERVER_NAME']);
    }
    elseif (isset($_SERVER['SERVER_ADDR'])) {
      $uri = $uri
        ->withHost($_SERVER['SERVER_ADDR']);
    }
    if (!$hasPort && isset($_SERVER['SERVER_PORT'])) {
      $uri = $uri
        ->withPort($_SERVER['SERVER_PORT']);
    }
    $hasQuery = false;
    if (isset($_SERVER['REQUEST_URI'])) {
      $requestUriParts = explode('?', $_SERVER['REQUEST_URI'], 2);
      $uri = $uri
        ->withPath($requestUriParts[0]);
      if (isset($requestUriParts[1])) {
        $hasQuery = true;
        $uri = $uri
          ->withQuery($requestUriParts[1]);
      }
    }
    if (!$hasQuery && isset($_SERVER['QUERY_STRING'])) {
      $uri = $uri
        ->withQuery($_SERVER['QUERY_STRING']);
    }
    return $uri;
  }

  /**
   * {@inheritdoc}
   */
  public function getServerParams() {
    return $this->serverParams;
  }

  /**
   * {@inheritdoc}
   */
  public function getUploadedFiles() {
    return $this->uploadedFiles;
  }

  /**
   * {@inheritdoc}
   */
  public function withUploadedFiles(array $uploadedFiles) {
    $new = clone $this;
    $new->uploadedFiles = $uploadedFiles;
    return $new;
  }

  /**
   * {@inheritdoc}
   */
  public function getCookieParams() {
    return $this->cookieParams;
  }

  /**
   * {@inheritdoc}
   */
  public function withCookieParams(array $cookies) {
    $new = clone $this;
    $new->cookieParams = $cookies;
    return $new;
  }

  /**
   * {@inheritdoc}
   */
  public function getQueryParams() {
    return $this->queryParams;
  }

  /**
   * {@inheritdoc}
   */
  public function withQueryParams(array $query) {
    $new = clone $this;
    $new->queryParams = $query;
    return $new;
  }

  /**
   * {@inheritdoc}
   */
  public function getParsedBody() {
    return $this->parsedBody;
  }

  /**
   * {@inheritdoc}
   */
  public function withParsedBody($data) {
    $new = clone $this;
    $new->parsedBody = $data;
    return $new;
  }

  /**
   * {@inheritdoc}
   */
  public function getAttributes() {
    return $this->attributes;
  }

  /**
   * {@inheritdoc}
   */
  public function getAttribute($attribute, $default = null) {
    if (false === array_key_exists($attribute, $this->attributes)) {
      return $default;
    }
    return $this->attributes[$attribute];
  }

  /**
   * {@inheritdoc}
   */
  public function withAttribute($attribute, $value) {
    $new = clone $this;
    $new->attributes[$attribute] = $value;
    return $new;
  }

  /**
   * {@inheritdoc}
   */
  public function withoutAttribute($attribute) {
    if (false === array_key_exists($attribute, $this->attributes)) {
      return $this;
    }
    $new = clone $this;
    unset($new->attributes[$attribute]);
    return $new;
  }

}

Members

Name	Modifiers	Type	Description
MessageTrait::$headerNames	private	property	@var array Map of lowercase header name => original name at registration
MessageTrait::$headers	private	property	@var array Map of all registered headers, as original name => array of values
MessageTrait::$protocol	private	property	@var string
MessageTrait::$stream	private	property	@var StreamInterface
MessageTrait::getBody	public	function
MessageTrait::getHeader	public	function
MessageTrait::getHeaderLine	public	function
MessageTrait::getHeaders	public	function
MessageTrait::getProtocolVersion	public	function
MessageTrait::hasHeader	public	function
MessageTrait::setHeaders	private	function
MessageTrait::trimHeaderValues	private	function	Trims whitespace from the header values.
MessageTrait::withAddedHeader	public	function
MessageTrait::withBody	public	function
MessageTrait::withHeader	public	function
MessageTrait::withoutHeader	public	function
MessageTrait::withProtocolVersion	public	function
Request::$method	private	property	@var string
Request::$requestTarget	private	property	@var null\|string
Request::$uri	private	property	@var UriInterface
Request::getMethod	public	function	Retrieves the HTTP method of the request. Overrides RequestInterface::getMethod
Request::getRequestTarget	public	function	Retrieves the message's request target. Overrides RequestInterface::getRequestTarget
Request::getUri	public	function	Retrieves the URI instance. Overrides RequestInterface::getUri
Request::updateHostFromUri	private	function
Request::withMethod	public	function	Return an instance with the provided HTTP method. Overrides RequestInterface::withMethod
Request::withRequestTarget	public	function	Return an instance with the specific request-target. Overrides RequestInterface::withRequestTarget
Request::withUri	public	function	Returns an instance with the provided URI. Overrides RequestInterface::withUri
ServerRequest::$attributes	private	property
ServerRequest::$cookieParams	private	property
ServerRequest::$parsedBody	private	property
ServerRequest::$queryParams	private	property
ServerRequest::$serverParams	private	property
ServerRequest::$uploadedFiles	private	property
ServerRequest::createUploadedFileFromSpec	private static	function	Create and return an UploadedFile instance from a $_FILES specification.
ServerRequest::extractHostAndPortFromAuthority	private static	function
ServerRequest::fromGlobals	public static	function	Return a ServerRequest populated with superglobals: $_GET $_POST $_COOKIE $_FILES $_SERVER
ServerRequest::getAttribute	public	function	Retrieve a single derived request attribute. Overrides ServerRequestInterface::getAttribute
ServerRequest::getAttributes	public	function	Retrieve attributes derived from the request. Overrides ServerRequestInterface::getAttributes
ServerRequest::getCookieParams	public	function	Retrieve cookies. Overrides ServerRequestInterface::getCookieParams
ServerRequest::getParsedBody	public	function	Retrieve any parameters provided in the request body. Overrides ServerRequestInterface::getParsedBody
ServerRequest::getQueryParams	public	function	Retrieve query string arguments. Overrides ServerRequestInterface::getQueryParams
ServerRequest::getServerParams	public	function	Retrieve server parameters. Overrides ServerRequestInterface::getServerParams
ServerRequest::getUploadedFiles	public	function	Retrieve normalized file upload data. Overrides ServerRequestInterface::getUploadedFiles
ServerRequest::getUriFromGlobals	public static	function	Get a Uri populated with values from $_SERVER.
ServerRequest::normalizeFiles	public static	function	Return an UploadedFile instance array.
ServerRequest::normalizeNestedFileSpec	private static	function	Normalize an array of file specifications.
ServerRequest::withAttribute	public	function	Return an instance with the specified derived request attribute. Overrides ServerRequestInterface::withAttribute
ServerRequest::withCookieParams	public	function	Return an instance with the specified cookies. Overrides ServerRequestInterface::withCookieParams
ServerRequest::withoutAttribute	public	function	Return an instance that removes the specified derived request attribute. Overrides ServerRequestInterface::withoutAttribute
ServerRequest::withParsedBody	public	function	Return an instance with the specified body parameters. Overrides ServerRequestInterface::withParsedBody
ServerRequest::withQueryParams	public	function	Return an instance with the specified query string arguments. Overrides ServerRequestInterface::withQueryParams
ServerRequest::withUploadedFiles	public	function	Create a new instance with the specified uploaded files. Overrides ServerRequestInterface::withUploadedFiles
ServerRequest::__construct	public	function	Overrides Request::__construct

You are here

class ServerRequest in Lockr 7.3

Hierarchy

File

Namespace

Members

API Navigation