diff options
author | Andrew Dolgov <[email protected]> | 2022-11-23 21:14:33 +0300 |
---|---|---|
committer | Andrew Dolgov <[email protected]> | 2022-11-23 21:14:33 +0300 |
commit | 0c8af4992cb0f7589dcafaad65ada12753c64594 (patch) | |
tree | 18e83d068c3e7dd2499331de977782b382279396 /vendor/aws/aws-sdk-php/src/Api |
initial
Diffstat (limited to 'vendor/aws/aws-sdk-php/src/Api')
41 files changed, 4835 insertions, 0 deletions
diff --git a/vendor/aws/aws-sdk-php/src/Api/AbstractModel.php b/vendor/aws/aws-sdk-php/src/Api/AbstractModel.php new file mode 100644 index 0000000..2c9b412 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/AbstractModel.php @@ -0,0 +1,89 @@ +<?php +namespace Aws\Api; + +/** + * Base class that is used by most API shapes + */ +abstract class AbstractModel implements \ArrayAccess +{ + /** @var array */ + protected $definition; + + /** @var ShapeMap */ + protected $shapeMap; + + /** @var array */ + protected $contextParam; + + /** + * @param array $definition Service description + * @param ShapeMap $shapeMap Shapemap used for creating shapes + */ + public function __construct(array $definition, ShapeMap $shapeMap) + { + $this->definition = $definition; + $this->shapeMap = $shapeMap; + if (isset($definition['contextParam'])) { + $this->contextParam = $definition['contextParam']; + } + } + + public function toArray() + { + return $this->definition; + } + + /** + * @return mixed|null + */ + #[\ReturnTypeWillChange] + public function offsetGet($offset) + { + return isset($this->definition[$offset]) + ? $this->definition[$offset] : null; + } + + /** + * @return void + */ + #[\ReturnTypeWillChange] + public function offsetSet($offset, $value) + { + $this->definition[$offset] = $value; + } + + /** + * @return bool + */ + #[\ReturnTypeWillChange] + public function offsetExists($offset) + { + return isset($this->definition[$offset]); + } + + /** + * @return void + */ + #[\ReturnTypeWillChange] + public function offsetUnset($offset) + { + unset($this->definition[$offset]); + } + + protected function shapeAt($key) + { + if (!isset($this->definition[$key])) { + throw new \InvalidArgumentException('Expected shape definition at ' + . $key); + } + + return $this->shapeFor($this->definition[$key]); + } + + protected function shapeFor(array $definition) + { + return isset($definition['shape']) + ? $this->shapeMap->resolve($definition) + : Shape::create($definition, $this->shapeMap); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ApiProvider.php b/vendor/aws/aws-sdk-php/src/Api/ApiProvider.php new file mode 100644 index 0000000..b6a3a55 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ApiProvider.php @@ -0,0 +1,244 @@ +<?php +namespace Aws\Api; + +use Aws\Exception\UnresolvedApiException; + +/** + * API providers. + * + * An API provider is a function that accepts a type, service, and version and + * returns an array of API data on success or NULL if no API data can be created + * for the provided arguments. + * + * You can wrap your calls to an API provider with the + * {@see ApiProvider::resolve} method to ensure that API data is created. If the + * API data is not created, then the resolve() method will throw a + * {@see Aws\Exception\UnresolvedApiException}. + * + * use Aws\Api\ApiProvider; + * $provider = ApiProvider::defaultProvider(); + * // Returns an array or NULL. + * $data = $provider('api', 's3', '2006-03-01'); + * // Returns an array or throws. + * $data = ApiProvider::resolve($provider, 'api', 'elasticfood', '2020-01-01'); + * + * You can compose multiple providers into a single provider using + * {@see Aws\or_chain}. This method accepts providers as arguments and + * returns a new function that will invoke each provider until a non-null value + * is returned. + * + * $a = ApiProvider::filesystem(sys_get_temp_dir() . '/aws-beta-models'); + * $b = ApiProvider::manifest(); + * + * $c = \Aws\or_chain($a, $b); + * $data = $c('api', 'betaservice', '2015-08-08'); // $a handles this. + * $data = $c('api', 's3', '2006-03-01'); // $b handles this. + * $data = $c('api', 'invalid', '2014-12-15'); // Neither handles this. + */ +class ApiProvider +{ + /** @var array A map of public API type names to their file suffix. */ + private static $typeMap = [ + 'api' => 'api-2', + 'paginator' => 'paginators-1', + 'waiter' => 'waiters-2', + 'docs' => 'docs-2', + ]; + + /** @var array API manifest */ + private $manifest; + + /** @var string The directory containing service models. */ + private $modelsDir; + + /** + * Resolves an API provider and ensures a non-null return value. + * + * @param callable $provider Provider function to invoke. + * @param string $type Type of data ('api', 'waiter', 'paginator'). + * @param string $service Service name. + * @param string $version API version. + * + * @return array + * @throws UnresolvedApiException + */ + public static function resolve(callable $provider, $type, $service, $version) + { + // Execute the provider and return the result, if there is one. + $result = $provider($type, $service, $version); + if (is_array($result)) { + if (!isset($result['metadata']['serviceIdentifier'])) { + $result['metadata']['serviceIdentifier'] = $service; + } + return $result; + } + + // Throw an exception with a message depending on the inputs. + if (!isset(self::$typeMap[$type])) { + $msg = "The type must be one of: " . implode(', ', self::$typeMap); + } elseif ($service) { + $msg = "The {$service} service does not have version: {$version}."; + } else { + $msg = "You must specify a service name to retrieve its API data."; + } + + throw new UnresolvedApiException($msg); + } + + /** + * Default SDK API provider. + * + * This provider loads pre-built manifest data from the `data` directory. + * + * @return self + */ + public static function defaultProvider() + { + return new self(__DIR__ . '/../data', \Aws\manifest()); + } + + /** + * Loads API data after resolving the version to the latest, compatible, + * available version based on the provided manifest data. + * + * Manifest data is essentially an associative array of service names to + * associative arrays of API version aliases. + * + * [ + * ... + * 'ec2' => [ + * 'latest' => '2014-10-01', + * '2014-10-01' => '2014-10-01', + * '2014-09-01' => '2014-10-01', + * '2014-06-15' => '2014-10-01', + * ... + * ], + * 'ecs' => [...], + * 'elasticache' => [...], + * ... + * ] + * + * @param string $dir Directory containing service models. + * @param array $manifest The API version manifest data. + * + * @return self + */ + public static function manifest($dir, array $manifest) + { + return new self($dir, $manifest); + } + + /** + * Loads API data from the specified directory. + * + * If "latest" is specified as the version, this provider must glob the + * directory to find which is the latest available version. + * + * @param string $dir Directory containing service models. + * + * @return self + * @throws \InvalidArgumentException if the provided `$dir` is invalid. + */ + public static function filesystem($dir) + { + return new self($dir); + } + + /** + * Retrieves a list of valid versions for the specified service. + * + * @param string $service Service name + * + * @return array + */ + public function getVersions($service) + { + if (!isset($this->manifest)) { + $this->buildVersionsList($service); + } + + if (!isset($this->manifest[$service]['versions'])) { + return []; + } + + return array_values(array_unique($this->manifest[$service]['versions'])); + } + + /** + * Execute the provider. + * + * @param string $type Type of data ('api', 'waiter', 'paginator'). + * @param string $service Service name. + * @param string $version API version. + * + * @return array|null + */ + public function __invoke($type, $service, $version) + { + // Resolve the type or return null. + if (isset(self::$typeMap[$type])) { + $type = self::$typeMap[$type]; + } else { + return null; + } + + // Resolve the version or return null. + if (!isset($this->manifest)) { + $this->buildVersionsList($service); + } + + if (!isset($this->manifest[$service]['versions'][$version])) { + return null; + } + + $version = $this->manifest[$service]['versions'][$version]; + $path = "{$this->modelsDir}/{$service}/{$version}/{$type}.json"; + + try { + return \Aws\load_compiled_json($path); + } catch (\InvalidArgumentException $e) { + return null; + } + } + + /** + * @param string $modelsDir Directory containing service models. + * @param array $manifest The API version manifest data. + */ + private function __construct($modelsDir, array $manifest = null) + { + $this->manifest = $manifest; + $this->modelsDir = rtrim($modelsDir, '/'); + if (!is_dir($this->modelsDir)) { + throw new \InvalidArgumentException( + "The specified models directory, {$modelsDir}, was not found." + ); + } + } + + /** + * Build the versions list for the specified service by globbing the dir. + */ + private function buildVersionsList($service) + { + $dir = "{$this->modelsDir}/{$service}/"; + + if (!is_dir($dir)) { + return; + } + + // Get versions, remove . and .., and sort in descending order. + $results = array_diff(scandir($dir, SCANDIR_SORT_DESCENDING), ['..', '.']); + + if (!$results) { + $this->manifest[$service] = ['versions' => []]; + } else { + $this->manifest[$service] = [ + 'versions' => [ + 'latest' => $results[0] + ] + ]; + $this->manifest[$service]['versions'] += array_combine($results, $results); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/DateTimeResult.php b/vendor/aws/aws-sdk-php/src/Api/DateTimeResult.php new file mode 100644 index 0000000..cccf55b --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/DateTimeResult.php @@ -0,0 +1,124 @@ +<?php + +namespace Aws\Api; + +use Aws\Api\Parser\Exception\ParserException; +use DateTime; +use DateTimeZone; +use Exception; + +/** + * DateTime overrides that make DateTime work more seamlessly as a string, + * with JSON documents, and with JMESPath. + */ +class DateTimeResult extends \DateTime implements \JsonSerializable +{ + /** + * Create a new DateTimeResult from a unix timestamp. + * The Unix epoch (or Unix time or POSIX time or Unix + * timestamp) is the number of seconds that have elapsed since + * January 1, 1970 (midnight UTC/GMT). + * + * @return DateTimeResult + * @throws Exception + */ + public static function fromEpoch($unixTimestamp) + { + if (!is_numeric($unixTimestamp)) { + throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromEpoch'); + } + + // PHP 5.5 does not support sub-second precision + if (\PHP_VERSION_ID < 56000) { + return new self(gmdate('c', $unixTimestamp)); + } + + $decimalSeparator = isset(localeconv()['decimal_point']) ? localeconv()['decimal_point'] : "."; + $formatString = "U" . $decimalSeparator . "u"; + $dateTime = DateTime::createFromFormat( + $formatString, + sprintf('%0.6f', $unixTimestamp), + new DateTimeZone('UTC') + ); + + if (false === $dateTime) { + throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromEpoch'); + } + + return new self( + $dateTime->format('Y-m-d H:i:s.u'), + new DateTimeZone('UTC') + ); + } + + /** + * @return DateTimeResult + */ + public static function fromISO8601($iso8601Timestamp) + { + if (is_numeric($iso8601Timestamp) || !is_string($iso8601Timestamp)) { + throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromISO8601'); + } + + return new DateTimeResult($iso8601Timestamp); + } + + /** + * Create a new DateTimeResult from an unknown timestamp. + * + * @return DateTimeResult + * @throws Exception + */ + public static function fromTimestamp($timestamp, $expectedFormat = null) + { + if (empty($timestamp)) { + return self::fromEpoch(0); + } + + if (!(is_string($timestamp) || is_numeric($timestamp))) { + throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp'); + } + + try { + if ($expectedFormat == 'iso8601') { + try { + return self::fromISO8601($timestamp); + } catch (Exception $exception) { + return self::fromEpoch($timestamp); + } + } else if ($expectedFormat == 'unixTimestamp') { + try { + return self::fromEpoch($timestamp); + } catch (Exception $exception) { + return self::fromISO8601($timestamp); + } + } else if (\Aws\is_valid_epoch($timestamp)) { + return self::fromEpoch($timestamp); + } + return self::fromISO8601($timestamp); + } catch (Exception $exception) { + throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp'); + } + } + + /** + * Serialize the DateTimeResult as an ISO 8601 date string. + * + * @return string + */ + public function __toString() + { + return $this->format('c'); + } + + /** + * Serialize the date as an ISO 8601 date when serializing as JSON. + * + * @return string + */ + #[\ReturnTypeWillChange] + public function jsonSerialize() + { + return (string) $this; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/DocModel.php b/vendor/aws/aws-sdk-php/src/Api/DocModel.php new file mode 100644 index 0000000..3cc4da6 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/DocModel.php @@ -0,0 +1,128 @@ +<?php +namespace Aws\Api; + +/** + * Encapsulates the documentation strings for a given service-version and + * provides methods for extracting the desired parts related to a service, + * operation, error, or shape (i.e., parameter). + */ +class DocModel +{ + /** @var array */ + private $docs; + + /** + * @param array $docs + * + * @throws \RuntimeException + */ + public function __construct(array $docs) + { + if (!extension_loaded('tidy')) { + throw new \RuntimeException('The "tidy" PHP extension is required.'); + } + + $this->docs = $docs; + } + + /** + * Convert the doc model to an array. + * + * @return array + */ + public function toArray() + { + return $this->docs; + } + + /** + * Retrieves documentation about the service. + * + * @return null|string + */ + public function getServiceDocs() + { + return isset($this->docs['service']) ? $this->docs['service'] : null; + } + + /** + * Retrieves documentation about an operation. + * + * @param string $operation Name of the operation + * + * @return null|string + */ + public function getOperationDocs($operation) + { + return isset($this->docs['operations'][$operation]) + ? $this->docs['operations'][$operation] + : null; + } + + /** + * Retrieves documentation about an error. + * + * @param string $error Name of the error + * + * @return null|string + */ + public function getErrorDocs($error) + { + return isset($this->docs['shapes'][$error]['base']) + ? $this->docs['shapes'][$error]['base'] + : null; + } + + /** + * Retrieves documentation about a shape, specific to the context. + * + * @param string $shapeName Name of the shape. + * @param string $parentName Name of the parent/context shape. + * @param string $ref Name used by the context to reference the shape. + * + * @return null|string + */ + public function getShapeDocs($shapeName, $parentName, $ref) + { + if (!isset($this->docs['shapes'][$shapeName])) { + return ''; + } + + $result = ''; + $d = $this->docs['shapes'][$shapeName]; + if (isset($d['refs']["{$parentName}\$${ref}"])) { + $result = $d['refs']["{$parentName}\$${ref}"]; + } elseif (isset($d['base'])) { + $result = $d['base']; + } + + if (isset($d['append'])) { + $result .= $d['append']; + } + + return $this->clean($result); + } + + private function clean($content) + { + if (!$content) { + return ''; + } + + $tidy = new \tidy(); + $tidy->parseString($content, [ + 'indent' => true, + 'doctype' => 'omit', + 'output-html' => true, + 'show-body-only' => true, + 'drop-empty-paras' => true, + 'drop-font-tags' => true, + 'drop-proprietary-attributes' => true, + 'hide-comments' => true, + 'logical-emphasis' => true + ]); + $tidy->cleanRepair(); + + return (string) $content; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ErrorParser/AbstractErrorParser.php b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/AbstractErrorParser.php new file mode 100644 index 0000000..efce3d4 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/AbstractErrorParser.php @@ -0,0 +1,95 @@ +<?php +namespace Aws\Api\ErrorParser; + +use Aws\Api\Parser\MetadataParserTrait; +use Aws\Api\Parser\PayloadParserTrait; +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; + +abstract class AbstractErrorParser +{ + use MetadataParserTrait; + use PayloadParserTrait; + + /** + * @var Service + */ + protected $api; + + /** + * @param Service $api + */ + public function __construct(Service $api = null) + { + $this->api = $api; + } + + abstract protected function payload( + ResponseInterface $response, + StructureShape $member + ); + + protected function extractPayload( + StructureShape $member, + ResponseInterface $response + ) { + if ($member instanceof StructureShape) { + // Structure members parse top-level data into a specific key. + return $this->payload($response, $member); + } else { + // Streaming data is just the stream from the response body. + return $response->getBody(); + } + } + + protected function populateShape( + array &$data, + ResponseInterface $response, + CommandInterface $command = null + ) { + $data['body'] = []; + + if (!empty($command) && !empty($this->api)) { + + // If modeled error code is indicated, check for known error shape + if (!empty($data['code'])) { + + $errors = $this->api->getOperation($command->getName())->getErrors(); + foreach ($errors as $key => $error) { + + // If error code matches a known error shape, populate the body + if ($data['code'] == $error['name'] + && $error instanceof StructureShape + ) { + $modeledError = $error; + $data['body'] = $this->extractPayload( + $modeledError, + $response + ); + $data['error_shape'] = $modeledError; + + foreach ($error->getMembers() as $name => $member) { + switch ($member['location']) { + case 'header': + $this->extractHeader($name, $member, $response, $data['body']); + break; + case 'headers': + $this->extractHeaders($name, $member, $response, $data['body']); + break; + case 'statusCode': + $this->extractStatus($name, $response, $data['body']); + break; + } + } + + break; + } + } + } + } + + return $data; + } +}
\ No newline at end of file diff --git a/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonParserTrait.php b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonParserTrait.php new file mode 100644 index 0000000..92b447c --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonParserTrait.php @@ -0,0 +1,52 @@ +<?php +namespace Aws\Api\ErrorParser; + +use Aws\Api\Parser\PayloadParserTrait; +use Aws\Api\StructureShape; +use Psr\Http\Message\ResponseInterface; + +/** + * Provides basic JSON error parsing functionality. + */ +trait JsonParserTrait +{ + use PayloadParserTrait; + + private function genericHandler(ResponseInterface $response) + { + $code = (string) $response->getStatusCode(); + if ($this->api + && $this->api->getMetadata('awsQueryCompatible') + && $response->getHeaderLine('x-amzn-query-error') + ) { + $queryError = $response->getHeaderLine('x-amzn-query-error'); + $parts = explode(';', $queryError); + if (isset($parts) && count($parts) == 2 && $parts[0] && $parts[1]) { + $error_code = $parts[0]; + $error_type = $parts[1]; + } + } + if (!isset($error_type)) { + $error_type = $code[0] == '4' ? 'client' : 'server'; + } + + return [ + 'request_id' => (string) $response->getHeaderLine('x-amzn-requestid'), + 'code' => isset($error_code) ? $error_code : null, + 'message' => null, + 'type' => $error_type, + 'parsed' => $this->parseJson($response->getBody(), $response) + ]; + } + + protected function payload( + ResponseInterface $response, + StructureShape $member + ) { + $jsonBody = $this->parseJson($response->getBody(), $response); + + if ($jsonBody) { + return $this->parser->parse($member, $jsonBody); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonRpcErrorParser.php b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonRpcErrorParser.php new file mode 100644 index 0000000..8ac530e --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonRpcErrorParser.php @@ -0,0 +1,49 @@ +<?php +namespace Aws\Api\ErrorParser; + +use Aws\Api\Parser\JsonParser; +use Aws\Api\Service; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * Parsers JSON-RPC errors. + */ +class JsonRpcErrorParser extends AbstractErrorParser +{ + use JsonParserTrait; + + private $parser; + + public function __construct(Service $api = null, JsonParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new JsonParser(); + } + + public function __invoke( + ResponseInterface $response, + CommandInterface $command = null + ) { + $data = $this->genericHandler($response); + + // Make the casing consistent across services. + if ($data['parsed']) { + $data['parsed'] = array_change_key_case($data['parsed']); + } + + if (isset($data['parsed']['__type'])) { + if (!isset($data['code'])) { + $parts = explode('#', $data['parsed']['__type']); + $data['code'] = isset($parts[1]) ? $parts[1] : $parts[0]; + } + $data['message'] = isset($data['parsed']['message']) + ? $data['parsed']['message'] + : null; + } + + $this->populateShape($data, $response, $command); + + return $data; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ErrorParser/RestJsonErrorParser.php b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/RestJsonErrorParser.php new file mode 100644 index 0000000..2f7ba81 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/RestJsonErrorParser.php @@ -0,0 +1,58 @@ +<?php +namespace Aws\Api\ErrorParser; + +use Aws\Api\Parser\JsonParser; +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * Parses JSON-REST errors. + */ +class RestJsonErrorParser extends AbstractErrorParser +{ + use JsonParserTrait; + + private $parser; + + public function __construct(Service $api = null, JsonParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new JsonParser(); + } + + public function __invoke( + ResponseInterface $response, + CommandInterface $command = null + ) { + $data = $this->genericHandler($response); + + // Merge in error data from the JSON body + if ($json = $data['parsed']) { + $data = array_replace($data, $json); + } + + // Correct error type from services like Amazon Glacier + if (!empty($data['type'])) { + $data['type'] = strtolower($data['type']); + } + + // Retrieve the error code from services like Amazon Elastic Transcoder + if ($code = $response->getHeaderLine('x-amzn-errortype')) { + $colon = strpos($code, ':'); + $data['code'] = $colon ? substr($code, 0, $colon) : $code; + } + + // Retrieve error message directly + $data['message'] = isset($data['parsed']['message']) + ? $data['parsed']['message'] + : (isset($data['parsed']['Message']) + ? $data['parsed']['Message'] + : null); + + $this->populateShape($data, $response, $command); + + return $data; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ErrorParser/XmlErrorParser.php b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/XmlErrorParser.php new file mode 100644 index 0000000..41f61a4 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ErrorParser/XmlErrorParser.php @@ -0,0 +1,111 @@ +<?php +namespace Aws\Api\ErrorParser; + +use Aws\Api\Parser\PayloadParserTrait; +use Aws\Api\Parser\XmlParser; +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * Parses XML errors. + */ +class XmlErrorParser extends AbstractErrorParser +{ + use PayloadParserTrait; + + protected $parser; + + public function __construct(Service $api = null, XmlParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new XmlParser(); + } + + public function __invoke( + ResponseInterface $response, + CommandInterface $command = null + ) { + $code = (string) $response->getStatusCode(); + + $data = [ + 'type' => $code[0] == '4' ? 'client' : 'server', + 'request_id' => null, + 'code' => null, + 'message' => null, + 'parsed' => null + ]; + + $body = $response->getBody(); + if ($body->getSize() > 0) { + $this->parseBody($this->parseXml($body, $response), $data); + } else { + $this->parseHeaders($response, $data); + } + + $this->populateShape($data, $response, $command); + + return $data; + } + + private function parseHeaders(ResponseInterface $response, array &$data) + { + if ($response->getStatusCode() == '404') { + $data['code'] = 'NotFound'; + } + + $data['message'] = $response->getStatusCode() . ' ' + . $response->getReasonPhrase(); + + if ($requestId = $response->getHeaderLine('x-amz-request-id')) { + $data['request_id'] = $requestId; + $data['message'] .= " (Request-ID: $requestId)"; + } + } + + private function parseBody(\SimpleXMLElement $body, array &$data) + { + $data['parsed'] = $body; + $prefix = $this->registerNamespacePrefix($body); + + if ($tempXml = $body->xpath("//{$prefix}Code[1]")) { + $data['code'] = (string) $tempXml[0]; + } + + if ($tempXml = $body->xpath("//{$prefix}Message[1]")) { + $data['message'] = (string) $tempXml[0]; + } + + $tempXml = $body->xpath("//{$prefix}RequestId[1]"); + if (isset($tempXml[0])) { + $data['request_id'] = (string)$tempXml[0]; + } + } + + protected function registerNamespacePrefix(\SimpleXMLElement $element) + { + $namespaces = $element->getDocNamespaces(); + if (!isset($namespaces[''])) { + return ''; + } + + // Account for the default namespace being defined and PHP not + // being able to handle it :(. + $element->registerXPathNamespace('ns', $namespaces['']); + return 'ns:'; + } + + protected function payload( + ResponseInterface $response, + StructureShape $member + ) { + $xmlBody = $this->parseXml($response->getBody(), $response); + $prefix = $this->registerNamespacePrefix($xmlBody); + $errorBody = $xmlBody->xpath("//{$prefix}Error"); + + if (is_array($errorBody) && !empty($errorBody[0])) { + return $this->parser->parse($member, $errorBody[0]); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ListShape.php b/vendor/aws/aws-sdk-php/src/Api/ListShape.php new file mode 100644 index 0000000..a425efa --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ListShape.php @@ -0,0 +1,35 @@ +<?php +namespace Aws\Api; + +/** + * Represents a list shape. + */ +class ListShape extends Shape +{ + private $member; + + public function __construct(array $definition, ShapeMap $shapeMap) + { + $definition['type'] = 'list'; + parent::__construct($definition, $shapeMap); + } + + /** + * @return Shape + * @throws \RuntimeException if no member is specified + */ + public function getMember() + { + if (!$this->member) { + if (!isset($this->definition['member'])) { + throw new \RuntimeException('No member attribute specified'); + } + $this->member = Shape::create( + $this->definition['member'], + $this->shapeMap + ); + } + + return $this->member; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/MapShape.php b/vendor/aws/aws-sdk-php/src/Api/MapShape.php new file mode 100644 index 0000000..f180f9a --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/MapShape.php @@ -0,0 +1,54 @@ +<?php +namespace Aws\Api; + +/** + * Represents a map shape. + */ +class MapShape extends Shape +{ + /** @var Shape */ + private $value; + + /** @var Shape */ + private $key; + + public function __construct(array $definition, ShapeMap $shapeMap) + { + $definition['type'] = 'map'; + parent::__construct($definition, $shapeMap); + } + + /** + * @return Shape + * @throws \RuntimeException if no value is specified + */ + public function getValue() + { + if (!$this->value) { + if (!isset($this->definition['value'])) { + throw new \RuntimeException('No value specified'); + } + + $this->value = Shape::create( + $this->definition['value'], + $this->shapeMap + ); + } + + return $this->value; + } + + /** + * @return Shape + */ + public function getKey() + { + if (!$this->key) { + $this->key = isset($this->definition['key']) + ? Shape::create($this->definition['key'], $this->shapeMap) + : new Shape(['type' => 'string'], $this->shapeMap); + } + + return $this->key; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Operation.php b/vendor/aws/aws-sdk-php/src/Api/Operation.php new file mode 100644 index 0000000..cee94ac --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Operation.php @@ -0,0 +1,142 @@ +<?php +namespace Aws\Api; + +/** + * Represents an API operation. + */ +class Operation extends AbstractModel +{ + private $input; + private $output; + private $errors; + private $staticContextParams = []; + private $contextParams; + + public function __construct(array $definition, ShapeMap $shapeMap) + { + $definition['type'] = 'structure'; + + if (!isset($definition['http']['method'])) { + $definition['http']['method'] = 'POST'; + } + + if (!isset($definition['http']['requestUri'])) { + $definition['http']['requestUri'] = '/'; + } + + if (isset($definition['staticContextParams'])) { + $this->staticContextParams = $definition['staticContextParams']; + } + + parent::__construct($definition, $shapeMap); + $this->contextParams = $this->setContextParams(); + } + + /** + * Returns an associative array of the HTTP attribute of the operation: + * + * - method: HTTP method of the operation + * - requestUri: URI of the request (can include URI template placeholders) + * + * @return array + */ + public function getHttp() + { + return $this->definition['http']; + } + + /** + * Get the input shape of the operation. + * + * @return StructureShape + */ + public function getInput() + { + if (!$this->input) { + if ($input = $this['input']) { + $this->input = $this->shapeFor($input); + } else { + $this->input = new StructureShape([], $this->shapeMap); + } + } + + return $this->input; + } + + /** + * Get the output shape of the operation. + * + * @return StructureShape + */ + public function getOutput() + { + if (!$this->output) { + if ($output = $this['output']) { + $this->output = $this->shapeFor($output); + } else { + $this->output = new StructureShape([], $this->shapeMap); + } + } + + return $this->output; + } + + /** + * Get an array of operation error shapes. + * + * @return Shape[] + */ + public function getErrors() + { + if ($this->errors === null) { + if ($errors = $this['errors']) { + foreach ($errors as $key => $error) { + $errors[$key] = $this->shapeFor($error); + } + $this->errors = $errors; + } else { + $this->errors = []; + } + } + + return $this->errors; + } + + /** + * Gets static modeled static values used for + * endpoint resolution. + * + * @return array + */ + public function getStaticContextParams() + { + return $this->staticContextParams; + } + + /** + * Gets definition of modeled dynamic values used + * for endpoint resolution + * + * @return array + */ + public function getContextParams() + { + return $this->contextParams; + } + + private function setContextParams() + { + $members = $this->getInput()->getMembers(); + $contextParams = []; + + foreach($members as $name => $shape) { + if (!empty($contextParam = $shape->getContextParam())) { + $contextParams[$contextParam['name']] = [ + 'shape' => $name, + 'type' => $shape->getType() + ]; + } + } + return $contextParams; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractParser.php new file mode 100644 index 0000000..2d515d2 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractParser.php @@ -0,0 +1,46 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Aws\CommandInterface; +use Aws\ResultInterface; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; + +/** + * @internal + */ +abstract class AbstractParser +{ + /** @var \Aws\Api\Service Representation of the service API*/ + protected $api; + + /** @var callable */ + protected $parser; + + /** + * @param Service $api Service description. + */ + public function __construct(Service $api) + { + $this->api = $api; + } + + /** + * @param CommandInterface $command Command that was executed. + * @param ResponseInterface $response Response that was received. + * + * @return ResultInterface + */ + abstract public function __invoke( + CommandInterface $command, + ResponseInterface $response + ); + + abstract public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ); +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractRestParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractRestParser.php new file mode 100644 index 0000000..c977588 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/AbstractRestParser.php @@ -0,0 +1,184 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\DateTimeResult; +use Aws\Api\Shape; +use Aws\Api\StructureShape; +use Aws\Result; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; + +/** + * @internal + */ +abstract class AbstractRestParser extends AbstractParser +{ + use PayloadParserTrait; + + /** + * Parses a payload from a response. + * + * @param ResponseInterface $response Response to parse. + * @param StructureShape $member Member to parse + * @param array $result Result value + * + * @return mixed + */ + abstract protected function payload( + ResponseInterface $response, + StructureShape $member, + array &$result + ); + + public function __invoke( + CommandInterface $command, + ResponseInterface $response + ) { + $output = $this->api->getOperation($command->getName())->getOutput(); + $result = []; + + if ($payload = $output['payload']) { + $this->extractPayload($payload, $output, $response, $result); + } + + foreach ($output->getMembers() as $name => $member) { + switch ($member['location']) { + case 'header': + $this->extractHeader($name, $member, $response, $result); + break; + case 'headers': + $this->extractHeaders($name, $member, $response, $result); + break; + case 'statusCode': + $this->extractStatus($name, $response, $result); + break; + } + } + + if (!$payload + && $response->getBody()->getSize() > 0 + && count($output->getMembers()) > 0 + ) { + // if no payload was found, then parse the contents of the body + $this->payload($response, $output, $result); + } + + return new Result($result); + } + + private function extractPayload( + $payload, + StructureShape $output, + ResponseInterface $response, + array &$result + ) { + $member = $output->getMember($payload); + + if (!empty($member['eventstream'])) { + $result[$payload] = new EventParsingIterator( + $response->getBody(), + $member, + $this + ); + } else if ($member instanceof StructureShape) { + // Structure members parse top-level data into a specific key. + $result[$payload] = []; + $this->payload($response, $member, $result[$payload]); + } else { + // Streaming data is just the stream from the response body. + $result[$payload] = $response->getBody(); + } + } + + /** + * Extract a single header from the response into the result. + */ + private function extractHeader( + $name, + Shape $shape, + ResponseInterface $response, + &$result + ) { + $value = $response->getHeaderLine($shape['locationName'] ?: $name); + + switch ($shape->getType()) { + case 'float': + case 'double': + $value = (float) $value; + break; + case 'long': + $value = (int) $value; + break; + case 'boolean': + $value = filter_var($value, FILTER_VALIDATE_BOOLEAN); + break; + case 'blob': + $value = base64_decode($value); + break; + case 'timestamp': + try { + $value = DateTimeResult::fromTimestamp( + $value, + !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null + ); + break; + } catch (\Exception $e) { + // If the value cannot be parsed, then do not add it to the + // output structure. + return; + } + case 'string': + try { + if ($shape['jsonvalue']) { + $value = $this->parseJson(base64_decode($value), $response); + } + + // If value is not set, do not add to output structure. + if (!isset($value)) { + return; + } + break; + } catch (\Exception $e) { + //If the value cannot be parsed, then do not add it to the + //output structure. + return; + } + } + + $result[$name] = $value; + } + + /** + * Extract a map of headers with an optional prefix from the response. + */ + private function extractHeaders( + $name, + Shape $shape, + ResponseInterface $response, + &$result + ) { + // Check if the headers are prefixed by a location name + $result[$name] = []; + $prefix = $shape['locationName']; + $prefixLen = $prefix !== null ? strlen($prefix) : 0; + + foreach ($response->getHeaders() as $k => $values) { + if (!$prefixLen) { + $result[$name][$k] = implode(', ', $values); + } elseif (stripos($k, $prefix) === 0) { + $result[$name][substr($k, $prefixLen)] = implode(', ', $values); + } + } + } + + /** + * Places the status code of the response into the result array. + */ + private function extractStatus( + $name, + ResponseInterface $response, + array &$result + ) { + $result[$name] = (int) $response->getStatusCode(); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/Crc32ValidatingParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/Crc32ValidatingParser.php new file mode 100644 index 0000000..8e5d4f0 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/Crc32ValidatingParser.php @@ -0,0 +1,54 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\StructureShape; +use Aws\CommandInterface; +use Aws\Exception\AwsException; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; +use GuzzleHttp\Psr7; + +/** + * @internal Decorates a parser and validates the x-amz-crc32 header. + */ +class Crc32ValidatingParser extends AbstractParser +{ + /** + * @param callable $parser Parser to wrap. + */ + public function __construct(callable $parser) + { + $this->parser = $parser; + } + + public function __invoke( + CommandInterface $command, + ResponseInterface $response + ) { + if ($expected = $response->getHeaderLine('x-amz-crc32')) { + $hash = hexdec(Psr7\Utils::hash($response->getBody(), 'crc32b')); + if ($expected != $hash) { + throw new AwsException( + "crc32 mismatch. Expected {$expected}, found {$hash}.", + $command, + [ + 'code' => 'ClientChecksumMismatch', + 'connection_error' => true, + 'response' => $response + ] + ); + } + } + + $fn = $this->parser; + return $fn($command, $response); + } + + public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ) { + return $this->parser->parseMemberFromStream($stream, $member, $response); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/DecodingEventStreamIterator.php b/vendor/aws/aws-sdk-php/src/Api/Parser/DecodingEventStreamIterator.php new file mode 100644 index 0000000..7ad03bf --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/DecodingEventStreamIterator.php @@ -0,0 +1,340 @@ +<?php + +namespace Aws\Api\Parser; + +use \Iterator; +use Aws\Api\DateTimeResult; +use GuzzleHttp\Psr7; +use Psr\Http\Message\StreamInterface; +use Aws\Api\Parser\Exception\ParserException; + +/** + * @internal Implements a decoder for a binary encoded event stream that will + * decode, validate, and provide individual events from the stream. + */ +class DecodingEventStreamIterator implements Iterator +{ + const HEADERS = 'headers'; + const PAYLOAD = 'payload'; + + const LENGTH_TOTAL = 'total_length'; + const LENGTH_HEADERS = 'headers_length'; + + const CRC_PRELUDE = 'prelude_crc'; + + const BYTES_PRELUDE = 12; + const BYTES_TRAILING = 4; + + private static $preludeFormat = [ + self::LENGTH_TOTAL => 'decodeUint32', + self::LENGTH_HEADERS => 'decodeUint32', + self::CRC_PRELUDE => 'decodeUint32', + ]; + + private static $lengthFormatMap = [ + 1 => 'decodeUint8', + 2 => 'decodeUint16', + 4 => 'decodeUint32', + 8 => 'decodeUint64', + ]; + + private static $headerTypeMap = [ + 0 => 'decodeBooleanTrue', + 1 => 'decodeBooleanFalse', + 2 => 'decodeInt8', + 3 => 'decodeInt16', + 4 => 'decodeInt32', + 5 => 'decodeInt64', + 6 => 'decodeBytes', + 7 => 'decodeString', + 8 => 'decodeTimestamp', + 9 => 'decodeUuid', + ]; + + /** @var StreamInterface Stream of eventstream shape to parse. */ + private $stream; + + /** @var array Currently parsed event. */ + private $currentEvent; + + /** @var int Current in-order event key. */ + private $key; + + /** @var resource|\HashContext CRC32 hash context for event validation */ + private $hashContext; + + /** @var int $currentPosition */ + private $currentPosition; + + /** + * DecodingEventStreamIterator constructor. + * + * @param StreamInterface $stream + */ + public function __construct(StreamInterface $stream) + { + $this->stream = $stream; + $this->rewind(); + } + + private function parseHeaders($headerBytes) + { + $headers = []; + $bytesRead = 0; + + while ($bytesRead < $headerBytes) { + list($key, $numBytes) = $this->decodeString(1); + $bytesRead += $numBytes; + + list($type, $numBytes) = $this->decodeUint8(); + $bytesRead += $numBytes; + + $f = self::$headerTypeMap[$type]; + list($value, $numBytes) = $this->{$f}(); + $bytesRead += $numBytes; + + if (isset($headers[$key])) { + throw new ParserException('Duplicate key in event headers.'); + } + $headers[$key] = $value; + } + + return [$headers, $bytesRead]; + } + + private function parsePrelude() + { + $prelude = []; + $bytesRead = 0; + + $calculatedCrc = null; + foreach (self::$preludeFormat as $key => $decodeFunction) { + if ($key === self::CRC_PRELUDE) { + $hashCopy = hash_copy($this->hashContext); + $calculatedCrc = hash_final($this->hashContext, true); + $this->hashContext = $hashCopy; + } + list($value, $numBytes) = $this->{$decodeFunction}(); + $bytesRead += $numBytes; + + $prelude[$key] = $value; + } + + if (unpack('N', $calculatedCrc)[1] !== $prelude[self::CRC_PRELUDE]) { + throw new ParserException('Prelude checksum mismatch.'); + } + + return [$prelude, $bytesRead]; + } + + private function parseEvent() + { + $event = []; + + if ($this->stream->tell() < $this->stream->getSize()) { + $this->hashContext = hash_init('crc32b'); + + $bytesLeft = $this->stream->getSize() - $this->stream->tell(); + list($prelude, $numBytes) = $this->parsePrelude(); + if ($prelude[self::LENGTH_TOTAL] > $bytesLeft) { + throw new ParserException('Message length too long.'); + } + $bytesLeft -= $numBytes; + + if ($prelude[self::LENGTH_HEADERS] > $bytesLeft) { + throw new ParserException('Headers length too long.'); + } + + list( + $event[self::HEADERS], + $numBytes + ) = $this->parseHeaders($prelude[self::LENGTH_HEADERS]); + + $event[self::PAYLOAD] = Psr7\Utils::streamFor( + $this->readAndHashBytes( + $prelude[self::LENGTH_TOTAL] - self::BYTES_PRELUDE + - $numBytes - self::BYTES_TRAILING + ) + ); + + $calculatedCrc = hash_final($this->hashContext, true); + $messageCrc = $this->stream->read(4); + if ($calculatedCrc !== $messageCrc) { + throw new ParserException('Message checksum mismatch.'); + } + } + + return $event; + } + + // Iterator Functionality + + /** + * @return array + */ + #[\ReturnTypeWillChange] + public function current() + { + return $this->currentEvent; + } + + /** + * @return int + */ + #[\ReturnTypeWillChange] + public function key() + { + return $this->key; + } + + #[\ReturnTypeWillChange] + public function next() + { + $this->currentPosition = $this->stream->tell(); + if ($this->valid()) { + $this->key++; + $this->currentEvent = $this->parseEvent(); + } + } + + #[\ReturnTypeWillChange] + public function rewind() + { + $this->stream->rewind(); + $this->key = 0; + $this->currentPosition = 0; + $this->currentEvent = $this->parseEvent(); + } + + /** + * @return bool + */ + #[\ReturnTypeWillChange] + public function valid() + { + return $this->currentPosition < $this->stream->getSize(); + } + + // Decoding Utilities + + private function readAndHashBytes($num) + { + $bytes = $this->stream->read($num); + hash_update($this->hashContext, $bytes); + return $bytes; + } + + private function decodeBooleanTrue() + { + return [true, 0]; + } + + private function decodeBooleanFalse() + { + return [false, 0]; + } + + private function uintToInt($val, $size) + { + $signedCap = pow(2, $size - 1); + if ($val > $signedCap) { + $val -= (2 * $signedCap); + } + return $val; + } + + private function decodeInt8() + { + $val = (int)unpack('C', $this->readAndHashBytes(1))[1]; + return [$this->uintToInt($val, 8), 1]; + } + + private function decodeUint8() + { + return [unpack('C', $this->readAndHashBytes(1))[1], 1]; + } + + private function decodeInt16() + { + $val = (int)unpack('n', $this->readAndHashBytes(2))[1]; + return [$this->uintToInt($val, 16), 2]; + } + + private function decodeUint16() + { + return [unpack('n', $this->readAndHashBytes(2))[1], 2]; + } + + private function decodeInt32() + { + $val = (int)unpack('N', $this->readAndHashBytes(4))[1]; + return [$this->uintToInt($val, 32), 4]; + } + + private function decodeUint32() + { + return [unpack('N', $this->readAndHashBytes(4))[1], 4]; + } + + private function decodeInt64() + { + $val = $this->unpackInt64($this->readAndHashBytes(8))[1]; + return [$this->uintToInt($val, 64), 8]; + } + + private function decodeUint64() + { + return [$this->unpackInt64($this->readAndHashBytes(8))[1], 8]; + } + + private function unpackInt64($bytes) + { + if (version_compare(PHP_VERSION, '5.6.3', '<')) { + $d = unpack('N2', $bytes); + return [1 => $d[1] << 32 | $d[2]]; + } + return unpack('J', $bytes); + } + + private function decodeBytes($lengthBytes=2) + { + if (!isset(self::$lengthFormatMap[$lengthBytes])) { + throw new ParserException('Undefined variable length format.'); + } + $f = self::$lengthFormatMap[$lengthBytes]; + list($len, $bytes) = $this->{$f}(); + return [$this->readAndHashBytes($len), $len + $bytes]; + } + + private function decodeString($lengthBytes=2) + { + if (!isset(self::$lengthFormatMap[$lengthBytes])) { + throw new ParserException('Undefined variable length format.'); + } + $f = self::$lengthFormatMap[$lengthBytes]; + list($len, $bytes) = $this->{$f}(); + return [$this->readAndHashBytes($len), $len + $bytes]; + } + + private function decodeTimestamp() + { + list($val, $bytes) = $this->decodeInt64(); + return [ + DateTimeResult::createFromFormat('U.u', $val / 1000), + $bytes + ]; + } + + private function decodeUuid() + { + $val = unpack('H32', $this->readAndHashBytes(16))[1]; + return [ + substr($val, 0, 8) . '-' + . substr($val, 8, 4) . '-' + . substr($val, 12, 4) . '-' + . substr($val, 16, 4) . '-' + . substr($val, 20, 12), + 16 + ]; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/EventParsingIterator.php b/vendor/aws/aws-sdk-php/src/Api/Parser/EventParsingIterator.php new file mode 100644 index 0000000..7ee35fb --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/EventParsingIterator.php @@ -0,0 +1,112 @@ +<?php + +namespace Aws\Api\Parser; + +use \Iterator; +use Aws\Exception\EventStreamDataException; +use Aws\Api\Parser\Exception\ParserException; +use Aws\Api\StructureShape; +use Psr\Http\Message\StreamInterface; + +/** + * @internal Implements a decoder for a binary encoded event stream that will + * decode, validate, and provide individual events from the stream. + */ +class EventParsingIterator implements Iterator +{ + /** @var StreamInterface */ + private $decodingIterator; + + /** @var StructureShape */ + private $shape; + + /** @var AbstractParser */ + private $parser; + + public function __construct( + StreamInterface $stream, + StructureShape $shape, + AbstractParser $parser + ) { + $this->decodingIterator = new DecodingEventStreamIterator($stream); + $this->shape = $shape; + $this->parser = $parser; + } + + #[\ReturnTypeWillChange] + public function current() + { + return $this->parseEvent($this->decodingIterator->current()); + } + + #[\ReturnTypeWillChange] + public function key() + { + return $this->decodingIterator->key(); + } + + #[\ReturnTypeWillChange] + public function next() + { + $this->decodingIterator->next(); + } + + #[\ReturnTypeWillChange] + public function rewind() + { + $this->decodingIterator->rewind(); + } + + #[\ReturnTypeWillChange] + public function valid() + { + return $this->decodingIterator->valid(); + } + + private function parseEvent(array $event) + { + if (!empty($event['headers'][':message-type'])) { + if ($event['headers'][':message-type'] === 'error') { + return $this->parseError($event); + } + if ($event['headers'][':message-type'] !== 'event') { + throw new ParserException('Failed to parse unknown message type.'); + } + } + + if (empty($event['headers'][':event-type'])) { + throw new ParserException('Failed to parse without event type.'); + } + $eventShape = $this->shape->getMember($event['headers'][':event-type']); + + $parsedEvent = []; + foreach ($eventShape['members'] as $shape => $details) { + if (!empty($details['eventpayload'])) { + $payloadShape = $eventShape->getMember($shape); + if ($payloadShape['type'] === 'blob') { + $parsedEvent[$shape] = $event['payload']; + } else { + $parsedEvent[$shape] = $this->parser->parseMemberFromStream( + $event['payload'], + $payloadShape, + null + ); + } + } else { + $parsedEvent[$shape] = $event['headers'][$shape]; + } + } + + return [ + $event['headers'][':event-type'] => $parsedEvent + ]; + } + + private function parseError(array $event) + { + throw new EventStreamDataException( + $event['headers'][':error-code'], + $event['headers'][':error-message'] + ); + } +}
\ No newline at end of file diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/Exception/ParserException.php b/vendor/aws/aws-sdk-php/src/Api/Parser/Exception/ParserException.php new file mode 100644 index 0000000..f5fd9ec --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/Exception/ParserException.php @@ -0,0 +1,56 @@ +<?php +namespace Aws\Api\Parser\Exception; + +use Aws\HasMonitoringEventsTrait; +use Aws\MonitoringEventsInterface; +use Aws\ResponseContainerInterface; +use Psr\Http\Message\ResponseInterface; + +class ParserException extends \RuntimeException implements + MonitoringEventsInterface, + ResponseContainerInterface +{ + use HasMonitoringEventsTrait; + + private $errorCode; + private $requestId; + private $response; + + public function __construct($message = '', $code = 0, $previous = null, array $context = []) + { + $this->errorCode = isset($context['error_code']) ? $context['error_code'] : null; + $this->requestId = isset($context['request_id']) ? $context['request_id'] : null; + $this->response = isset($context['response']) ? $context['response'] : null; + parent::__construct($message, $code, $previous); + } + + /** + * Get the error code, if any. + * + * @return string|null + */ + public function getErrorCode() + { + return $this->errorCode; + } + + /** + * Get the request ID, if any. + * + * @return string|null + */ + public function getRequestId() + { + return $this->requestId; + } + + /** + * Get the received HTTP response if any. + * + * @return ResponseInterface|null + */ + public function getResponse() + { + return $this->response; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/JsonParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/JsonParser.php new file mode 100644 index 0000000..ef98154 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/JsonParser.php @@ -0,0 +1,71 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\DateTimeResult; +use Aws\Api\Shape; + +/** + * @internal Implements standard JSON parsing. + */ +class JsonParser +{ + public function parse(Shape $shape, $value) + { + if ($value === null) { + return $value; + } + + switch ($shape['type']) { + case 'structure': + if (isset($shape['document']) && $shape['document']) { + return $value; + } + $target = []; + foreach ($shape->getMembers() as $name => $member) { + $locationName = $member['locationName'] ?: $name; + if (isset($value[$locationName])) { + $target[$name] = $this->parse($member, $value[$locationName]); + } + } + if (isset($shape['union']) + && $shape['union'] + && is_array($value) + && empty($target) + ) { + foreach ($value as $key => $val) { + $target['Unknown'][$key] = $val; + } + } + return $target; + + case 'list': + $member = $shape->getMember(); + $target = []; + foreach ($value as $v) { + $target[] = $this->parse($member, $v); + } + return $target; + + case 'map': + $values = $shape->getValue(); + $target = []; + foreach ($value as $k => $v) { + $target[$k] = $this->parse($values, $v); + } + return $target; + + case 'timestamp': + return DateTimeResult::fromTimestamp( + $value, + !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null + ); + + case 'blob': + return base64_decode($value); + + default: + return $value; + } + } +} + diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/JsonRpcParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/JsonRpcParser.php new file mode 100644 index 0000000..75e8715 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/JsonRpcParser.php @@ -0,0 +1,51 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\StructureShape; +use Aws\Api\Service; +use Aws\Result; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; + +/** + * @internal Implements JSON-RPC parsing (e.g., DynamoDB) + */ +class JsonRpcParser extends AbstractParser +{ + use PayloadParserTrait; + + /** + * @param Service $api Service description + * @param JsonParser $parser JSON body builder + */ + public function __construct(Service $api, JsonParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new JsonParser(); + } + + public function __invoke( + CommandInterface $command, + ResponseInterface $response + ) { + $operation = $this->api->getOperation($command->getName()); + $result = null === $operation['output'] + ? null + : $this->parseMemberFromStream( + $response->getBody(), + $operation->getOutput(), + $response + ); + + return new Result($result ?: []); + } + + public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ) { + return $this->parser->parse($member, $this->parseJson($stream, $response)); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/MetadataParserTrait.php b/vendor/aws/aws-sdk-php/src/Api/Parser/MetadataParserTrait.php new file mode 100644 index 0000000..e64d5a8 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/MetadataParserTrait.php @@ -0,0 +1,90 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\DateTimeResult; +use Aws\Api\Shape; +use Psr\Http\Message\ResponseInterface; + +trait MetadataParserTrait +{ + /** + * Extract a single header from the response into the result. + */ + protected function extractHeader( + $name, + Shape $shape, + ResponseInterface $response, + &$result + ) { + $value = $response->getHeaderLine($shape['locationName'] ?: $name); + + switch ($shape->getType()) { + case 'float': + case 'double': + $value = (float) $value; + break; + case 'long': + $value = (int) $value; + break; + case 'boolean': + $value = filter_var($value, FILTER_VALIDATE_BOOLEAN); + break; + case 'blob': + $value = base64_decode($value); + break; + case 'timestamp': + try { + $value = DateTimeResult::fromTimestamp( + $value, + !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null + ); + break; + } catch (\Exception $e) { + // If the value cannot be parsed, then do not add it to the + // output structure. + return; + } + case 'string': + if ($shape['jsonvalue']) { + $value = $this->parseJson(base64_decode($value), $response); + } + break; + } + + $result[$name] = $value; + } + + /** + * Extract a map of headers with an optional prefix from the response. + */ + protected function extractHeaders( + $name, + Shape $shape, + ResponseInterface $response, + &$result + ) { + // Check if the headers are prefixed by a location name + $result[$name] = []; + $prefix = $shape['locationName']; + $prefixLen = strlen($prefix); + + foreach ($response->getHeaders() as $k => $values) { + if (!$prefixLen) { + $result[$name][$k] = implode(', ', $values); + } elseif (stripos($k, $prefix) === 0) { + $result[$name][substr($k, $prefixLen)] = implode(', ', $values); + } + } + } + + /** + * Places the status code of the response into the result array. + */ + protected function extractStatus( + $name, + ResponseInterface $response, + array &$result + ) { + $result[$name] = (int) $response->getStatusCode(); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/PayloadParserTrait.php b/vendor/aws/aws-sdk-php/src/Api/Parser/PayloadParserTrait.php new file mode 100644 index 0000000..43d3d56 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/PayloadParserTrait.php @@ -0,0 +1,61 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\Parser\Exception\ParserException; +use Psr\Http\Message\ResponseInterface; + +trait PayloadParserTrait +{ + /** + * @param string $json + * + * @throws ParserException + * + * @return array + */ + private function parseJson($json, $response) + { + $jsonPayload = json_decode($json, true); + + if (JSON_ERROR_NONE !== json_last_error()) { + throw new ParserException( + 'Error parsing JSON: ' . json_last_error_msg(), + 0, + null, + ['response' => $response] + ); + } + + return $jsonPayload; + } + + /** + * @param string $xml + * + * @throws ParserException + * + * @return \SimpleXMLElement + */ + protected function parseXml($xml, $response) + { + $priorSetting = libxml_use_internal_errors(true); + try { + libxml_clear_errors(); + $xmlPayload = new \SimpleXMLElement($xml); + if ($error = libxml_get_last_error()) { + throw new \RuntimeException($error->message); + } + } catch (\Exception $e) { + throw new ParserException( + "Error parsing XML: {$e->getMessage()}", + 0, + $e, + ['response' => $response] + ); + } finally { + libxml_use_internal_errors($priorSetting); + } + + return $xmlPayload; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/QueryParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/QueryParser.php new file mode 100644 index 0000000..50e4e3a --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/QueryParser.php @@ -0,0 +1,60 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Aws\Result; +use Aws\CommandInterface; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; + +/** + * @internal Parses query (XML) responses (e.g., EC2, SQS, and many others) + */ +class QueryParser extends AbstractParser +{ + use PayloadParserTrait; + + /** @var bool */ + private $honorResultWrapper; + + /** + * @param Service $api Service description + * @param XmlParser $xmlParser Optional XML parser + * @param bool $honorResultWrapper Set to false to disable the peeling + * back of result wrappers from the + * output structure. + */ + public function __construct( + Service $api, + XmlParser $xmlParser = null, + $honorResultWrapper = true + ) { + parent::__construct($api); + $this->parser = $xmlParser ?: new XmlParser(); + $this->honorResultWrapper = $honorResultWrapper; + } + + public function __invoke( + CommandInterface $command, + ResponseInterface $response + ) { + $output = $this->api->getOperation($command->getName())->getOutput(); + $xml = $this->parseXml($response->getBody(), $response); + + if ($this->honorResultWrapper && $output['resultWrapper']) { + $xml = $xml->{$output['resultWrapper']}; + } + + return new Result($this->parser->parse($output, $xml)); + } + + public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ) { + $xml = $this->parseXml($stream, $response); + return $this->parser->parse($member, $xml); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/RestJsonParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/RestJsonParser.php new file mode 100644 index 0000000..76d8098 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/RestJsonParser.php @@ -0,0 +1,49 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\Service; +use Aws\Api\StructureShape; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; + +/** + * @internal Implements REST-JSON parsing (e.g., Glacier, Elastic Transcoder) + */ +class RestJsonParser extends AbstractRestParser +{ + use PayloadParserTrait; + + /** + * @param Service $api Service description + * @param JsonParser $parser JSON body builder + */ + public function __construct(Service $api, JsonParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new JsonParser(); + } + + protected function payload( + ResponseInterface $response, + StructureShape $member, + array &$result + ) { + $jsonBody = $this->parseJson($response->getBody(), $response); + + if ($jsonBody) { + $result += $this->parser->parse($member, $jsonBody); + } + } + + public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ) { + $jsonBody = $this->parseJson($stream, $response); + if ($jsonBody) { + return $this->parser->parse($member, $jsonBody); + } + return []; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/RestXmlParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/RestXmlParser.php new file mode 100644 index 0000000..d04429f --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/RestXmlParser.php @@ -0,0 +1,42 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\StructureShape; +use Aws\Api\Service; +use Psr\Http\Message\ResponseInterface; +use Psr\Http\Message\StreamInterface; + +/** + * @internal Implements REST-XML parsing (e.g., S3, CloudFront, etc...) + */ +class RestXmlParser extends AbstractRestParser +{ + use PayloadParserTrait; + + /** + * @param Service $api Service description + * @param XmlParser $parser XML body parser + */ + public function __construct(Service $api, XmlParser $parser = null) + { + parent::__construct($api); + $this->parser = $parser ?: new XmlParser(); + } + + protected function payload( + ResponseInterface $response, + StructureShape $member, + array &$result + ) { + $result += $this->parseMemberFromStream($response->getBody(), $member, $response); + } + + public function parseMemberFromStream( + StreamInterface $stream, + StructureShape $member, + $response + ) { + $xml = $this->parseXml($stream, $response); + return $this->parser->parse($member, $xml); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Parser/XmlParser.php b/vendor/aws/aws-sdk-php/src/Api/Parser/XmlParser.php new file mode 100644 index 0000000..744f02e --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Parser/XmlParser.php @@ -0,0 +1,179 @@ +<?php +namespace Aws\Api\Parser; + +use Aws\Api\DateTimeResult; +use Aws\Api\ListShape; +use Aws\Api\MapShape; +use Aws\Api\Parser\Exception\ParserException; +use Aws\Api\Shape; +use Aws\Api\StructureShape; + +/** + * @internal Implements standard XML parsing for REST-XML and Query protocols. + */ +class XmlParser +{ + public function parse(StructureShape $shape, \SimpleXMLElement $value) + { + return $this->dispatch($shape, $value); + } + + private function dispatch($shape, \SimpleXMLElement $value) + { + static $methods = [ + 'structure' => 'parse_structure', + 'list' => 'parse_list', + 'map' => 'parse_map', + 'blob' => 'parse_blob', + 'boolean' => 'parse_boolean', + 'integer' => 'parse_integer', + 'float' => 'parse_float', + 'double' => 'parse_float', + 'timestamp' => 'parse_timestamp', + ]; + + $type = $shape['type']; + if (isset($methods[$type])) { + return $this->{$methods[$type]}($shape, $value); + } + + return (string) $value; + } + + private function parse_structure( + StructureShape $shape, + \SimpleXMLElement $value + ) { + $target = []; + + foreach ($shape->getMembers() as $name => $member) { + // Extract the name of the XML node + $node = $this->memberKey($member, $name); + if (isset($value->{$node})) { + $target[$name] = $this->dispatch($member, $value->{$node}); + } else { + $memberShape = $shape->getMember($name); + if (!empty($memberShape['xmlAttribute'])) { + $target[$name] = $this->parse_xml_attribute( + $shape, + $memberShape, + $value + ); + } + } + } + if (isset($shape['union']) + && $shape['union'] + && empty($target) + ) { + foreach ($value as $key => $val) { + $name = $val->children()->getName(); + $target['Unknown'][$name] = $val->$name; + } + } + return $target; + } + + private function memberKey(Shape $shape, $name) + { + if (null !== $shape['locationName']) { + return $shape['locationName']; + } + + if ($shape instanceof ListShape && $shape['flattened']) { + return $shape->getMember()['locationName'] ?: $name; + } + + return $name; + } + + private function parse_list(ListShape $shape, \SimpleXMLElement $value) + { + $target = []; + $member = $shape->getMember(); + + if (!$shape['flattened']) { + $value = $value->{$member['locationName'] ?: 'member'}; + } + + foreach ($value as $v) { + $target[] = $this->dispatch($member, $v); + } + + return $target; + } + + private function parse_map(MapShape $shape, \SimpleXMLElement $value) + { + $target = []; + + if (!$shape['flattened']) { + $value = $value->entry; + } + + $mapKey = $shape->getKey(); + $mapValue = $shape->getValue(); + $keyName = $shape->getKey()['locationName'] ?: 'key'; + $valueName = $shape->getValue()['locationName'] ?: 'value'; + + foreach ($value as $node) { + $key = $this->dispatch($mapKey, $node->{$keyName}); + $value = $this->dispatch($mapValue, $node->{$valueName}); + $target[$key] = $value; + } + + return $target; + } + + private function parse_blob(Shape $shape, $value) + { + return base64_decode((string) $value); + } + + private function parse_float(Shape $shape, $value) + { + return (float) (string) $value; + } + + private function parse_integer(Shape $shape, $value) + { + return (int) (string) $value; + } + + private function parse_boolean(Shape $shape, $value) + { + return $value == 'true'; + } + + private function parse_timestamp(Shape $shape, $value) + { + if (is_string($value) + || is_int($value) + || (is_object($value) + && method_exists($value, '__toString')) + ) { + return DateTimeResult::fromTimestamp( + (string) $value, + !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null + ); + } + throw new ParserException('Invalid timestamp value passed to XmlParser::parse_timestamp'); + } + + private function parse_xml_attribute(Shape $shape, Shape $memberShape, $value) + { + $namespace = $shape['xmlNamespace']['uri'] + ? $shape['xmlNamespace']['uri'] + : ''; + $prefix = $shape['xmlNamespace']['prefix'] + ? $shape['xmlNamespace']['prefix'] + : ''; + if (!empty($prefix)) { + $prefix .= ':'; + } + $key = str_replace($prefix, '', $memberShape['locationName']); + + $attributes = $value->attributes($namespace); + return isset($attributes[$key]) ? (string) $attributes[$key] : null; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/Ec2ParamBuilder.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/Ec2ParamBuilder.php new file mode 100644 index 0000000..fc88c7b --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/Ec2ParamBuilder.php @@ -0,0 +1,40 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\Shape; +use Aws\Api\ListShape; + +/** + * @internal + */ +class Ec2ParamBuilder extends QueryParamBuilder +{ + protected function queryName(Shape $shape, $default = null) + { + return ($shape['queryName'] + ?: ucfirst(@$shape['locationName'] ?: "")) + ?: $default; + } + + protected function isFlat(Shape $shape) + { + return false; + } + + protected function format_list( + ListShape $shape, + array $value, + $prefix, + &$query + ) { + // Handle empty list serialization + if (!$value) { + $query[$prefix] = false; + } else { + $items = $shape->getMember(); + foreach ($value as $k => $v) { + $this->format($items, $v, $prefix . '.' . ($k + 1), $query); + } + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonBody.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonBody.php new file mode 100644 index 0000000..0b116e0 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonBody.php @@ -0,0 +1,108 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\Service; +use Aws\Api\Shape; +use Aws\Api\TimestampShape; +use Aws\Exception\InvalidJsonException; + +/** + * Formats the JSON body of a JSON-REST or JSON-RPC operation. + * @internal + */ +class JsonBody +{ + private $api; + + public function __construct(Service $api) + { + $this->api = $api; + } + + /** + * Gets the JSON Content-Type header for a service API + * + * @param Service $service + * + * @return string + */ + public static function getContentType(Service $service) + { + if ($service->getMetadata('protocol') === 'rest-json') { + return 'application/json'; + } + + $jsonVersion = $service->getMetadata('jsonVersion'); + if (empty($jsonVersion)) { + throw new \InvalidArgumentException('invalid json'); + } else { + return 'application/x-amz-json-' + . @number_format($service->getMetadata('jsonVersion'), 1); + } + } + + /** + * Builds the JSON body based on an array of arguments. + * + * @param Shape $shape Operation being constructed + * @param array $args Associative array of arguments + * + * @return string + */ + public function build(Shape $shape, array $args) + { + $result = json_encode($this->format($shape, $args)); + return $result == '[]' ? '{}' : $result; + } + + private function format(Shape $shape, $value) + { + switch ($shape['type']) { + case 'structure': + $data = []; + if (isset($shape['document']) && $shape['document']) { + return $value; + } + foreach ($value as $k => $v) { + if ($v !== null && $shape->hasMember($k)) { + $valueShape = $shape->getMember($k); + $data[$valueShape['locationName'] ?: $k] + = $this->format($valueShape, $v); + } + } + if (empty($data)) { + return new \stdClass; + } + return $data; + + case 'list': + $items = $shape->getMember(); + foreach ($value as $k => $v) { + $value[$k] = $this->format($items, $v); + } + return $value; + + case 'map': + if (empty($value)) { + return new \stdClass; + } + $values = $shape->getValue(); + foreach ($value as $k => $v) { + $value[$k] = $this->format($values, $v); + } + return $value; + + case 'blob': + return base64_encode($value); + + case 'timestamp': + $timestampFormat = !empty($shape['timestampFormat']) + ? $shape['timestampFormat'] + : 'unixTimestamp'; + return TimestampShape::format($value, $timestampFormat); + + default: + return $value; + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonRpcSerializer.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonRpcSerializer.php new file mode 100644 index 0000000..508766e --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/JsonRpcSerializer.php @@ -0,0 +1,92 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\Service; +use Aws\CommandInterface; +use Aws\EndpointV2\EndpointProviderV2; +use Aws\EndpointV2\EndpointV2SerializerTrait; +use GuzzleHttp\Psr7\Request; +use Psr\Http\Message\RequestInterface; + +/** + * Prepares a JSON-RPC request for transfer. + * @internal + */ +class JsonRpcSerializer +{ + use EndpointV2SerializerTrait; + + /** @var JsonBody */ + private $jsonFormatter; + + /** @var string */ + private $endpoint; + + /** @var Service */ + private $api; + + /** @var string */ + private $contentType; + + /** + * @param Service $api Service description + * @param string $endpoint Endpoint to connect to + * @param JsonBody $jsonFormatter Optional JSON formatter to use + */ + public function __construct( + Service $api, + $endpoint, + JsonBody $jsonFormatter = null + ) { + $this->endpoint = $endpoint; + $this->api = $api; + $this->jsonFormatter = $jsonFormatter ?: new JsonBody($this->api); + $this->contentType = JsonBody::getContentType($api); + } + + /** + * When invoked with an AWS command, returns a serialization array + * containing "method", "uri", "headers", and "body" key value pairs. + * + * @param CommandInterface $command Command to serialize into a request. + * @param $endpointProvider Provider used for dynamic endpoint resolution. + * @param $clientArgs Client arguments used for dynamic endpoint resolution. + * + * @return RequestInterface + */ + public function __invoke( + CommandInterface $command, + $endpointProvider = null, + $clientArgs = null + ) + { + $operationName = $command->getName(); + $operation = $this->api->getOperation($operationName); + $commandArgs = $command->toArray(); + $headers = [ + 'X-Amz-Target' => $this->api->getMetadata('targetPrefix') . '.' . $operationName, + 'Content-Type' => $this->contentType + ]; + + if ($endpointProvider instanceof EndpointProviderV2) { + $this->setRequestOptions( + $endpointProvider, + $command, + $operation, + $commandArgs, + $clientArgs, + $headers + ); + } + + return new Request( + $operation['http']['method'], + $this->endpoint, + $headers, + $this->jsonFormatter->build( + $operation->getInput(), + $commandArgs + ) + ); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/QueryParamBuilder.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/QueryParamBuilder.php new file mode 100644 index 0000000..3d96334 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/QueryParamBuilder.php @@ -0,0 +1,157 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\StructureShape; +use Aws\Api\ListShape; +use Aws\Api\MapShape; +use Aws\Api\Shape; +use Aws\Api\TimestampShape; + +/** + * @internal + */ +class QueryParamBuilder +{ + private $methods; + + protected function queryName(Shape $shape, $default = null) + { + if (null !== $shape['queryName']) { + return $shape['queryName']; + } + + if (null !== $shape['locationName']) { + return $shape['locationName']; + } + + if ($this->isFlat($shape) && !empty($shape['member']['locationName'])) { + return $shape['member']['locationName']; + } + + return $default; + } + + protected function isFlat(Shape $shape) + { + return $shape['flattened'] === true; + } + + public function __invoke(StructureShape $shape, array $params) + { + if (!$this->methods) { + $this->methods = array_fill_keys(get_class_methods($this), true); + } + + $query = []; + $this->format_structure($shape, $params, '', $query); + + return $query; + } + + protected function format(Shape $shape, $value, $prefix, array &$query) + { + $type = 'format_' . $shape['type']; + if (isset($this->methods[$type])) { + $this->{$type}($shape, $value, $prefix, $query); + } else { + $query[$prefix] = (string) $value; + } + } + + protected function format_structure( + StructureShape $shape, + array $value, + $prefix, + &$query + ) { + if ($prefix) { + $prefix .= '.'; + } + + foreach ($value as $k => $v) { + if ($shape->hasMember($k)) { + $member = $shape->getMember($k); + $this->format( + $member, + $v, + $prefix . $this->queryName($member, $k), + $query + ); + } + } + } + + protected function format_list( + ListShape $shape, + array $value, + $prefix, + &$query + ) { + // Handle empty list serialization + if (!$value) { + $query[$prefix] = ''; + return; + } + + $items = $shape->getMember(); + + if (!$this->isFlat($shape)) { + $locationName = $shape->getMember()['locationName'] ?: 'member'; + $prefix .= ".$locationName"; + } elseif ($name = $this->queryName($items)) { + $parts = explode('.', $prefix); + $parts[count($parts) - 1] = $name; + $prefix = implode('.', $parts); + } + + foreach ($value as $k => $v) { + $this->format($items, $v, $prefix . '.' . ($k + 1), $query); + } + } + + protected function format_map( + MapShape $shape, + array $value, + $prefix, + array &$query + ) { + $vals = $shape->getValue(); + $keys = $shape->getKey(); + + if (!$this->isFlat($shape)) { + $prefix .= '.entry'; + } + + $i = 0; + $keyName = '%s.%d.' . $this->queryName($keys, 'key'); + $valueName = '%s.%s.' . $this->queryName($vals, 'value'); + + foreach ($value as $k => $v) { + $i++; + $this->format($keys, $k, sprintf($keyName, $prefix, $i), $query); + $this->format($vals, $v, sprintf($valueName, $prefix, $i), $query); + } + } + + protected function format_blob(Shape $shape, $value, $prefix, array &$query) + { + $query[$prefix] = base64_encode($value); + } + + protected function format_timestamp( + TimestampShape $shape, + $value, + $prefix, + array &$query + ) { + $timestampFormat = !empty($shape['timestampFormat']) + ? $shape['timestampFormat'] + : 'iso8601'; + $query[$prefix] = TimestampShape::format($value, $timestampFormat); + } + + protected function format_boolean(Shape $shape, $value, $prefix, array &$query) + { + $query[$prefix] = ($value) ? 'true' : 'false'; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/QuerySerializer.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/QuerySerializer.php new file mode 100644 index 0000000..a565d50 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/QuerySerializer.php @@ -0,0 +1,88 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\Service; +use Aws\CommandInterface; +use Aws\EndpointV2\EndpointProviderV2; +use Aws\EndpointV2\EndpointV2SerializerTrait; +use GuzzleHttp\Psr7\Request; +use Psr\Http\Message\RequestInterface; + +/** + * Serializes a query protocol request. + * @internal + */ +class QuerySerializer +{ + use EndpointV2SerializerTrait; + + private $endpoint; + private $api; + private $paramBuilder; + + public function __construct( + Service $api, + $endpoint, + callable $paramBuilder = null + ) { + $this->api = $api; + $this->endpoint = $endpoint; + $this->paramBuilder = $paramBuilder ?: new QueryParamBuilder(); + } + + /** + * When invoked with an AWS command, returns a serialization array + * containing "method", "uri", "headers", and "body" key value pairs. + * + * @param CommandInterface $command Command to serialize into a request. + * @param $endpointProvider Provider used for dynamic endpoint resolution. + * @param $clientArgs Client arguments used for dynamic endpoint resolution. + * + * @return RequestInterface + */ + public function __invoke( + CommandInterface $command, + $endpointProvider = null, + $clientArgs = null + ) + { + $operation = $this->api->getOperation($command->getName()); + $body = [ + 'Action' => $command->getName(), + 'Version' => $this->api->getMetadata('apiVersion') + ]; + $commandArgs = $command->toArray(); + + // Only build up the parameters when there are parameters to build + if ($commandArgs) { + $body += call_user_func( + $this->paramBuilder, + $operation->getInput(), + $commandArgs + ); + } + $body = http_build_query($body, '', '&', PHP_QUERY_RFC3986); + $headers = [ + 'Content-Length' => strlen($body), + 'Content-Type' => 'application/x-www-form-urlencoded' + ]; + + if ($endpointProvider instanceof EndpointProviderV2) { + $this->setRequestOptions( + $endpointProvider, + $command, + $operation, + $commandArgs, + $clientArgs, + $headers + ); + } + + return new Request( + 'POST', + $this->endpoint, + $headers, + $body + ); + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/RestJsonSerializer.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestJsonSerializer.php new file mode 100644 index 0000000..8a2aa99 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestJsonSerializer.php @@ -0,0 +1,42 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\Service; +use Aws\Api\StructureShape; + +/** + * Serializes requests for the REST-JSON protocol. + * @internal + */ +class RestJsonSerializer extends RestSerializer +{ + /** @var JsonBody */ + private $jsonFormatter; + + /** @var string */ + private $contentType; + + /** + * @param Service $api Service API description + * @param string $endpoint Endpoint to connect to + * @param JsonBody $jsonFormatter Optional JSON formatter to use + */ + public function __construct( + Service $api, + $endpoint, + JsonBody $jsonFormatter = null + ) { + parent::__construct($api, $endpoint); + $this->contentType = JsonBody::getContentType($api); + $this->jsonFormatter = $jsonFormatter ?: new JsonBody($api); + } + + protected function payload(StructureShape $member, array $value, array &$opts) + { + $body = isset($value) ? + ((string) $this->jsonFormatter->build($member, $value)) + : "{}"; + $opts['headers']['Content-Type'] = $this->contentType; + $opts['body'] = $body; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/RestSerializer.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestSerializer.php new file mode 100644 index 0000000..dbd925a --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestSerializer.php @@ -0,0 +1,307 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\MapShape; +use Aws\Api\Service; +use Aws\Api\Operation; +use Aws\Api\Shape; +use Aws\Api\StructureShape; +use Aws\Api\TimestampShape; +use Aws\CommandInterface; +use Aws\EndpointV2\EndpointProviderV2; +use Aws\EndpointV2\EndpointV2SerializerTrait; +use GuzzleHttp\Psr7; +use GuzzleHttp\Psr7\Request; +use GuzzleHttp\Psr7\Uri; +use GuzzleHttp\Psr7\UriResolver; +use Psr\Http\Message\RequestInterface; + +/** + * Serializes HTTP locations like header, uri, payload, etc... + * @internal + */ +abstract class RestSerializer +{ + use EndpointV2SerializerTrait; + + /** @var Service */ + private $api; + + /** @var Uri */ + private $endpoint; + + /** + * @param Service $api Service API description + * @param string $endpoint Endpoint to connect to + */ + public function __construct(Service $api, $endpoint) + { + $this->api = $api; + $this->endpoint = Psr7\Utils::uriFor($endpoint); + } + + /** + * @param CommandInterface $command Command to serialize into a request. + * @param $endpointProvider Provider used for dynamic endpoint resolution. + * @param $clientArgs Client arguments used for dynamic endpoint resolution. + * + * @return RequestInterface + */ + public function __invoke( + CommandInterface $command, + $endpointProvider = null, + $clientArgs = null + ) + { + $operation = $this->api->getOperation($command->getName()); + $commandArgs = $command->toArray(); + $opts = $this->serialize($operation, $commandArgs); + $headers = isset($opts['headers']) ? $opts['headers'] : []; + + if ($endpointProvider instanceof EndpointProviderV2) { + $this->setRequestOptions( + $endpointProvider, + $command, + $operation, + $commandArgs, + $clientArgs, + $headers + ); + $this->endpoint = new Uri($this->endpoint); + } + $uri = $this->buildEndpoint($operation, $commandArgs, $opts); + + return new Request( + $operation['http']['method'], + $uri, + $headers, + isset($opts['body']) ? $opts['body'] : null + ); + } + + /** + * Modifies a hash of request options for a payload body. + * + * @param StructureShape $member Member to serialize + * @param array $value Value to serialize + * @param array $opts Request options to modify. + */ + abstract protected function payload( + StructureShape $member, + array $value, + array &$opts + ); + + private function serialize(Operation $operation, array $args) + { + $opts = []; + $input = $operation->getInput(); + + // Apply the payload trait if present + if ($payload = $input['payload']) { + $this->applyPayload($input, $payload, $args, $opts); + } + + foreach ($args as $name => $value) { + if ($input->hasMember($name)) { + $member = $input->getMember($name); + $location = $member['location']; + if (!$payload && !$location) { + $bodyMembers[$name] = $value; + } elseif ($location == 'header') { + $this->applyHeader($name, $member, $value, $opts); + } elseif ($location == 'querystring') { + $this->applyQuery($name, $member, $value, $opts); + } elseif ($location == 'headers') { + $this->applyHeaderMap($name, $member, $value, $opts); + } + } + } + + if (isset($bodyMembers)) { + $this->payload($operation->getInput(), $bodyMembers, $opts); + } else if (!isset($opts['body']) && $this->hasPayloadParam($input, $payload)) { + $this->payload($operation->getInput(), [], $opts); + } + + return $opts; + } + + private function applyPayload(StructureShape $input, $name, array $args, array &$opts) + { + if (!isset($args[$name])) { + return; + } + + $m = $input->getMember($name); + + if ($m['streaming'] || + ($m['type'] == 'string' || $m['type'] == 'blob') + ) { + // Streaming bodies or payloads that are strings are + // always just a stream of data. + $opts['body'] = Psr7\Utils::streamFor($args[$name]); + return; + } + + $this->payload($m, $args[$name], $opts); + } + + private function applyHeader($name, Shape $member, $value, array &$opts) + { + if ($member->getType() === 'timestamp') { + $timestampFormat = !empty($member['timestampFormat']) + ? $member['timestampFormat'] + : 'rfc822'; + $value = TimestampShape::format($value, $timestampFormat); + } elseif ($member->getType() === 'boolean') { + $value = $value ? 'true' : 'false'; + } + + if ($member['jsonvalue']) { + $value = json_encode($value); + if (empty($value) && JSON_ERROR_NONE !== json_last_error()) { + throw new \InvalidArgumentException('Unable to encode the provided value' + . ' with \'json_encode\'. ' . json_last_error_msg()); + } + + $value = base64_encode($value); + } + + $opts['headers'][$member['locationName'] ?: $name] = $value; + } + + /** + * Note: This is currently only present in the Amazon S3 model. + */ + private function applyHeaderMap($name, Shape $member, array $value, array &$opts) + { + $prefix = $member['locationName']; + foreach ($value as $k => $v) { + $opts['headers'][$prefix . $k] = $v; + } + } + + private function applyQuery($name, Shape $member, $value, array &$opts) + { + if ($member instanceof MapShape) { + $opts['query'] = isset($opts['query']) && is_array($opts['query']) + ? $opts['query'] + $value + : $value; + } elseif ($value !== null) { + $type = $member->getType(); + if ($type === 'boolean') { + $value = $value ? 'true' : 'false'; + } elseif ($type === 'timestamp') { + $timestampFormat = !empty($member['timestampFormat']) + ? $member['timestampFormat'] + : 'iso8601'; + $value = TimestampShape::format($value, $timestampFormat); + } + + $opts['query'][$member['locationName'] ?: $name] = $value; + } + } + + private function buildEndpoint(Operation $operation, array $args, array $opts) + { + // Create an associative array of variable definitions used in expansions + $varDefinitions = $this->getVarDefinitions($operation, $args); + + $relative = preg_replace_callback( + '/\{([^\}]+)\}/', + function (array $matches) use ($varDefinitions) { + $isGreedy = substr($matches[1], -1, 1) == '+'; + $k = $isGreedy ? substr($matches[1], 0, -1) : $matches[1]; + if (!isset($varDefinitions[$k])) { + return ''; + } + + if ($isGreedy) { + return str_replace('%2F', '/', rawurlencode($varDefinitions[$k])); + } + + return rawurlencode($varDefinitions[$k]); + }, + $operation['http']['requestUri'] + ); + + // Add the query string variables or appending to one if needed. + if (!empty($opts['query'])) { + $relative = $this->appendQuery($opts['query'], $relative); + } + + $path = $this->endpoint->getPath(); + + //Accounts for trailing '/' in path when custom endpoint + //is provided to endpointProviderV2 + if ($this->api->isModifiedModel() + && $this->api->getServiceName() === 's3' + ) { + if (substr($path, -1) === '/' && $relative[0] === '/') { + $path = rtrim($path, '/'); + } + $relative = $path . $relative; + } + // If endpoint has path, remove leading '/' to preserve URI resolution. + if ($path && $relative[0] === '/') { + $relative = substr($relative, 1); + } + + //Append path to endpoint when leading '//...' present + // as uri cannot be properly resolved + if ($this->api->isModifiedModel() + && strpos($relative, '//') === 0 + ) { + return new Uri($this->endpoint . $relative); + } + + // Expand path place holders using Amazon's slightly different URI + // template syntax. + return UriResolver::resolve($this->endpoint, new Uri($relative)); + } + + /** + * @param StructureShape $input + */ + private function hasPayloadParam(StructureShape $input, $payload) + { + if ($payload) { + $potentiallyEmptyTypes = ['blob','string']; + if ($this->api->getMetadata('protocol') == 'rest-xml') { + $potentiallyEmptyTypes[] = 'structure'; + } + $payloadMember = $input->getMember($payload); + if (in_array($payloadMember['type'], $potentiallyEmptyTypes)) { + return false; + } + } + foreach ($input->getMembers() as $member) { + if (!isset($member['location'])) { + return true; + } + } + return false; + } + + private function appendQuery($query, $endpoint) + { + $append = Psr7\Query::build($query); + return $endpoint .= strpos($endpoint, '?') !== false ? "&{$append}" : "?{$append}"; + } + + private function getVarDefinitions($command, $args) + { + $varDefinitions = []; + + foreach ($command->getInput()->getMembers() as $name => $member) { + if ($member['location'] == 'uri') { + $varDefinitions[$member['locationName'] ?: $name] = + isset($args[$name]) + ? $args[$name] + : null; + } + } + return $varDefinitions; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/RestXmlSerializer.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestXmlSerializer.php new file mode 100644 index 0000000..200b89a --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/RestXmlSerializer.php @@ -0,0 +1,48 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\StructureShape; +use Aws\Api\Service; + +/** + * @internal + */ +class RestXmlSerializer extends RestSerializer +{ + /** @var XmlBody */ + private $xmlBody; + + /** + * @param Service $api Service API description + * @param string $endpoint Endpoint to connect to + * @param XmlBody $xmlBody Optional XML formatter to use + */ + public function __construct( + Service $api, + $endpoint, + XmlBody $xmlBody = null + ) { + parent::__construct($api, $endpoint); + $this->xmlBody = $xmlBody ?: new XmlBody($api); + } + + protected function payload(StructureShape $member, array $value, array &$opts) + { + $opts['headers']['Content-Type'] = 'application/xml'; + $opts['body'] = $this->getXmlBody($member, $value); + } + + /** + * @param StructureShape $member + * @param array $value + * @return string + */ + private function getXmlBody(StructureShape $member, array $value) + { + $xmlBody = (string)$this->xmlBody->build($member, $value); + $xmlBody = str_replace("'", "'", $xmlBody); + $xmlBody = str_replace('\r', " ", $xmlBody); + $xmlBody = str_replace('\n', " ", $xmlBody); + return $xmlBody; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Serializer/XmlBody.php b/vendor/aws/aws-sdk-php/src/Api/Serializer/XmlBody.php new file mode 100644 index 0000000..0488eba --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Serializer/XmlBody.php @@ -0,0 +1,220 @@ +<?php +namespace Aws\Api\Serializer; + +use Aws\Api\MapShape; +use Aws\Api\Service; +use Aws\Api\Shape; +use Aws\Api\StructureShape; +use Aws\Api\ListShape; +use Aws\Api\TimestampShape; +use XMLWriter; + +/** + * @internal Formats the XML body of a REST-XML services. + */ +class XmlBody +{ + /** @var \Aws\Api\Service */ + private $api; + + /** + * @param Service $api API being used to create the XML body. + */ + public function __construct(Service $api) + { + $this->api = $api; + } + + /** + * Builds the XML body based on an array of arguments. + * + * @param Shape $shape Operation being constructed + * @param array $args Associative array of arguments + * + * @return string + */ + public function build(Shape $shape, array $args) + { + $xml = new XMLWriter(); + $xml->openMemory(); + $xml->startDocument('1.0', 'UTF-8'); + $this->format($shape, $shape['locationName'] ?: $shape['name'], $args, $xml); + $xml->endDocument(); + + return $xml->outputMemory(); + } + + private function startElement(Shape $shape, $name, XMLWriter $xml) + { + $xml->startElement($name); + + if ($ns = $shape['xmlNamespace']) { + $xml->writeAttribute( + isset($ns['prefix']) ? "xmlns:{$ns['prefix']}" : 'xmlns', + $shape['xmlNamespace']['uri'] + ); + } + } + + private function format(Shape $shape, $name, $value, XMLWriter $xml) + { + // Any method mentioned here has a custom serialization handler. + static $methods = [ + 'add_structure' => true, + 'add_list' => true, + 'add_blob' => true, + 'add_timestamp' => true, + 'add_boolean' => true, + 'add_map' => true, + 'add_string' => true + ]; + + $type = 'add_' . $shape['type']; + if (isset($methods[$type])) { + $this->{$type}($shape, $name, $value, $xml); + } else { + $this->defaultShape($shape, $name, $value, $xml); + } + } + + private function defaultShape(Shape $shape, $name, $value, XMLWriter $xml) + { + $this->startElement($shape, $name, $xml); + $xml->text($value); + $xml->endElement(); + } + + private function add_structure( + StructureShape $shape, + $name, + array $value, + \XMLWriter $xml + ) { + $this->startElement($shape, $name, $xml); + + foreach ($this->getStructureMembers($shape, $value) as $k => $definition) { + $this->format( + $definition['member'], + $definition['member']['locationName'] ?: $k, + $definition['value'], + $xml + ); + } + + $xml->endElement(); + } + + private function getStructureMembers(StructureShape $shape, array $value) + { + $members = []; + + foreach ($value as $k => $v) { + if ($v !== null && $shape->hasMember($k)) { + $definition = [ + 'member' => $shape->getMember($k), + 'value' => $v, + ]; + + if ($definition['member']['xmlAttribute']) { + // array_unshift_associative + $members = [$k => $definition] + $members; + } else { + $members[$k] = $definition; + } + } + } + + return $members; + } + + private function add_list( + ListShape $shape, + $name, + array $value, + XMLWriter $xml + ) { + $items = $shape->getMember(); + + if ($shape['flattened']) { + $elementName = $name; + } else { + $this->startElement($shape, $name, $xml); + $elementName = $items['locationName'] ?: 'member'; + } + + foreach ($value as $v) { + $this->format($items, $elementName, $v, $xml); + } + + if (!$shape['flattened']) { + $xml->endElement(); + } + } + + private function add_map( + MapShape $shape, + $name, + array $value, + XMLWriter $xml + ) { + $xmlEntry = $shape['flattened'] ? $shape['locationName'] : 'entry'; + $xmlKey = $shape->getKey()['locationName'] ?: 'key'; + $xmlValue = $shape->getValue()['locationName'] ?: 'value'; + + $this->startElement($shape, $name, $xml); + + foreach ($value as $key => $v) { + $this->startElement($shape, $xmlEntry, $xml); + $this->format($shape->getKey(), $xmlKey, $key, $xml); + $this->format($shape->getValue(), $xmlValue, $v, $xml); + $xml->endElement(); + } + + $xml->endElement(); + } + + private function add_blob(Shape $shape, $name, $value, XMLWriter $xml) + { + $this->startElement($shape, $name, $xml); + $xml->writeRaw(base64_encode($value)); + $xml->endElement(); + } + + private function add_timestamp( + TimestampShape $shape, + $name, + $value, + XMLWriter $xml + ) { + $this->startElement($shape, $name, $xml); + $timestampFormat = !empty($shape['timestampFormat']) + ? $shape['timestampFormat'] + : 'iso8601'; + $xml->writeRaw(TimestampShape::format($value, $timestampFormat)); + $xml->endElement(); + } + + private function add_boolean( + Shape $shape, + $name, + $value, + XMLWriter $xml + ) { + $this->startElement($shape, $name, $xml); + $xml->writeRaw($value ? 'true' : 'false'); + $xml->endElement(); + } + + private function add_string( + Shape $shape, + $name, + $value, + XMLWriter $xml + ) { + if ($shape['xmlAttribute']) { + $xml->writeAttribute($shape['locationName'] ?: $name, $value); + } else { + $this->defaultShape($shape, $name, $value, $xml); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Service.php b/vendor/aws/aws-sdk-php/src/Api/Service.php new file mode 100644 index 0000000..c5c25a3 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Service.php @@ -0,0 +1,539 @@ +<?php +namespace Aws\Api; + +use Aws\Api\Serializer\QuerySerializer; +use Aws\Api\Serializer\Ec2ParamBuilder; +use Aws\Api\Parser\QueryParser; + +/** + * Represents a web service API model. + */ +class Service extends AbstractModel +{ + /** @var callable */ + private $apiProvider; + + /** @var string */ + private $serviceName; + + /** @var string */ + private $apiVersion; + + /** @var array */ + private $clientContextParams = []; + + /** @var Operation[] */ + private $operations = []; + + /** @var array */ + private $paginators = null; + + /** @var array */ + private $waiters = null; + + /** @var boolean */ + private $modifiedModel = false; + + /** + * @param array $definition + * @param callable $provider + * + * @internal param array $definition Service description + */ + public function __construct(array $definition, callable $provider) + { + static $defaults = [ + 'operations' => [], + 'shapes' => [], + 'metadata' => [], + 'clientContextParams' => [] + ], $defaultMeta = [ + 'apiVersion' => null, + 'serviceFullName' => null, + 'serviceId' => null, + 'endpointPrefix' => null, + 'signingName' => null, + 'signatureVersion' => null, + 'protocol' => null, + 'uid' => null + ]; + + $definition += $defaults; + $definition['metadata'] += $defaultMeta; + $this->definition = $definition; + $this->apiProvider = $provider; + parent::__construct($definition, new ShapeMap($definition['shapes'])); + + if (isset($definition['metadata']['serviceIdentifier'])) { + $this->serviceName = $this->getServiceName(); + } else { + $this->serviceName = $this->getEndpointPrefix(); + } + $this->apiVersion = $this->getApiVersion(); + if (isset($definition['clientContextParams'])) { + $this->clientContextParams = $definition['clientContextParams']; + } + } + + /** + * Creates a request serializer for the provided API object. + * + * @param Service $api API that contains a protocol. + * @param string $endpoint Endpoint to send requests to. + * + * @return callable + * @throws \UnexpectedValueException + */ + public static function createSerializer(Service $api, $endpoint) + { + static $mapping = [ + 'json' => 'Aws\Api\Serializer\JsonRpcSerializer', + 'query' => 'Aws\Api\Serializer\QuerySerializer', + 'rest-json' => 'Aws\Api\Serializer\RestJsonSerializer', + 'rest-xml' => 'Aws\Api\Serializer\RestXmlSerializer' + ]; + + $proto = $api->getProtocol(); + + if (isset($mapping[$proto])) { + return new $mapping[$proto]($api, $endpoint); + } + + if ($proto == 'ec2') { + return new QuerySerializer($api, $endpoint, new Ec2ParamBuilder()); + } + + throw new \UnexpectedValueException( + 'Unknown protocol: ' . $api->getProtocol() + ); + } + + /** + * Creates an error parser for the given protocol. + * + * Redundant method signature to preserve backwards compatibility. + * + * @param string $protocol Protocol to parse (e.g., query, json, etc.) + * + * @return callable + * @throws \UnexpectedValueException + */ + public static function createErrorParser($protocol, Service $api = null) + { + static $mapping = [ + 'json' => 'Aws\Api\ErrorParser\JsonRpcErrorParser', + 'query' => 'Aws\Api\ErrorParser\XmlErrorParser', + 'rest-json' => 'Aws\Api\ErrorParser\RestJsonErrorParser', + 'rest-xml' => 'Aws\Api\ErrorParser\XmlErrorParser', + 'ec2' => 'Aws\Api\ErrorParser\XmlErrorParser' + ]; + + if (isset($mapping[$protocol])) { + return new $mapping[$protocol]($api); + } + + throw new \UnexpectedValueException("Unknown protocol: $protocol"); + } + + /** + * Applies the listeners needed to parse client models. + * + * @param Service $api API to create a parser for + * @return callable + * @throws \UnexpectedValueException + */ + public static function createParser(Service $api) + { + static $mapping = [ + 'json' => 'Aws\Api\Parser\JsonRpcParser', + 'query' => 'Aws\Api\Parser\QueryParser', + 'rest-json' => 'Aws\Api\Parser\RestJsonParser', + 'rest-xml' => 'Aws\Api\Parser\RestXmlParser' + ]; + + $proto = $api->getProtocol(); + if (isset($mapping[$proto])) { + return new $mapping[$proto]($api); + } + + if ($proto == 'ec2') { + return new QueryParser($api, null, false); + } + + throw new \UnexpectedValueException( + 'Unknown protocol: ' . $api->getProtocol() + ); + } + + /** + * Get the full name of the service + * + * @return string + */ + public function getServiceFullName() + { + return $this->definition['metadata']['serviceFullName']; + } + + /** + * Get the service id + * + * @return string + */ + public function getServiceId() + { + return $this->definition['metadata']['serviceId']; + } + + /** + * Get the API version of the service + * + * @return string + */ + public function getApiVersion() + { + return $this->definition['metadata']['apiVersion']; + } + + /** + * Get the API version of the service + * + * @return string + */ + public function getEndpointPrefix() + { + return $this->definition['metadata']['endpointPrefix']; + } + + /** + * Get the signing name used by the service. + * + * @return string + */ + public function getSigningName() + { + return $this->definition['metadata']['signingName'] + ?: $this->definition['metadata']['endpointPrefix']; + } + + /** + * Get the service name. + * + * @return string + */ + public function getServiceName() + { + return $this->definition['metadata']['serviceIdentifier']; + } + + /** + * Get the default signature version of the service. + * + * Note: this method assumes "v4" when not specified in the model. + * + * @return string + */ + public function getSignatureVersion() + { + return $this->definition['metadata']['signatureVersion'] ?: 'v4'; + } + + /** + * Get the protocol used by the service. + * + * @return string + */ + public function getProtocol() + { + return $this->definition['metadata']['protocol']; + } + + /** + * Get the uid string used by the service + * + * @return string + */ + public function getUid() + { + return $this->definition['metadata']['uid']; + } + + /** + * Check if the description has a specific operation by name. + * + * @param string $name Operation to check by name + * + * @return bool + */ + public function hasOperation($name) + { + return isset($this['operations'][$name]); + } + + /** + * Get an operation by name. + * + * @param string $name Operation to retrieve by name + * + * @return Operation + * @throws \InvalidArgumentException If the operation is not found + */ + public function getOperation($name) + { + if (!isset($this->operations[$name])) { + if (!isset($this->definition['operations'][$name])) { + throw new \InvalidArgumentException("Unknown operation: $name"); + } + $this->operations[$name] = new Operation( + $this->definition['operations'][$name], + $this->shapeMap + ); + } else if ($this->modifiedModel) { + $this->operations[$name] = new Operation( + $this->definition['operations'][$name], + $this->shapeMap + ); + } + + return $this->operations[$name]; + } + + /** + * Get all of the operations of the description. + * + * @return Operation[] + */ + public function getOperations() + { + $result = []; + foreach ($this->definition['operations'] as $name => $definition) { + $result[$name] = $this->getOperation($name); + } + + return $result; + } + + /** + * Get all of the error shapes of the service + * + * @return array + */ + public function getErrorShapes() + { + $result = []; + foreach ($this->definition['shapes'] as $name => $definition) { + if (!empty($definition['exception'])) { + $definition['name'] = $name; + $result[] = new StructureShape($definition, $this->getShapeMap()); + } + } + + return $result; + } + + /** + * Get all of the service metadata or a specific metadata key value. + * + * @param string|null $key Key to retrieve or null to retrieve all metadata + * + * @return mixed Returns the result or null if the key is not found + */ + public function getMetadata($key = null) + { + if (!$key) { + return $this['metadata']; + } + + if (isset($this->definition['metadata'][$key])) { + return $this->definition['metadata'][$key]; + } + + return null; + } + + /** + * Gets an associative array of available paginator configurations where + * the key is the name of the paginator, and the value is the paginator + * configuration. + * + * @return array + * @unstable The configuration format of paginators may change in the future + */ + public function getPaginators() + { + if (!isset($this->paginators)) { + $res = call_user_func( + $this->apiProvider, + 'paginator', + $this->serviceName, + $this->apiVersion + ); + $this->paginators = isset($res['pagination']) + ? $res['pagination'] + : []; + } + + return $this->paginators; + } + + /** + * Determines if the service has a paginator by name. + * + * @param string $name Name of the paginator. + * + * @return bool + */ + public function hasPaginator($name) + { + return isset($this->getPaginators()[$name]); + } + + /** + * Retrieve a paginator by name. + * + * @param string $name Paginator to retrieve by name. This argument is + * typically the operation name. + * @return array + * @throws \UnexpectedValueException if the paginator does not exist. + * @unstable The configuration format of paginators may change in the future + */ + public function getPaginatorConfig($name) + { + static $defaults = [ + 'input_token' => null, + 'output_token' => null, + 'limit_key' => null, + 'result_key' => null, + 'more_results' => null, + ]; + + if ($this->hasPaginator($name)) { + return $this->paginators[$name] + $defaults; + } + + throw new \UnexpectedValueException("There is no {$name} " + . "paginator defined for the {$this->serviceName} service."); + } + + /** + * Gets an associative array of available waiter configurations where the + * key is the name of the waiter, and the value is the waiter + * configuration. + * + * @return array + */ + public function getWaiters() + { + if (!isset($this->waiters)) { + $res = call_user_func( + $this->apiProvider, + 'waiter', + $this->serviceName, + $this->apiVersion + ); + $this->waiters = isset($res['waiters']) + ? $res['waiters'] + : []; + } + + return $this->waiters; + } + + /** + * Determines if the service has a waiter by name. + * + * @param string $name Name of the waiter. + * + * @return bool + */ + public function hasWaiter($name) + { + return isset($this->getWaiters()[$name]); + } + + /** + * Get a waiter configuration by name. + * + * @param string $name Name of the waiter by name. + * + * @return array + * @throws \UnexpectedValueException if the waiter does not exist. + */ + public function getWaiterConfig($name) + { + // Error if the waiter is not defined + if ($this->hasWaiter($name)) { + return $this->waiters[$name]; + } + + throw new \UnexpectedValueException("There is no {$name} waiter " + . "defined for the {$this->serviceName} service."); + } + + /** + * Get the shape map used by the API. + * + * @return ShapeMap + */ + public function getShapeMap() + { + return $this->shapeMap; + } + + /** + * Get all the context params of the description. + * + * @return array + */ + public function getClientContextParams() + { + return $this->clientContextParams; + } + + /** + * Get the service's api provider. + * + * @return callable + */ + public function getProvider() + { + return $this->apiProvider; + } + + /** + * Get the service's definition. + * + * @return callable + */ + public function getDefinition() + { + return $this->definition; + } + + /** + * Sets the service's api definition. + * Intended for internal use only. + * + * @return void + * + * @internal + */ + public function setDefinition($definition) + { + $this->definition = $definition; + $this->modifiedModel = true; + } + + /** + * Denotes whether or not a service's definition has + * been modified. Intended for internal use only. + * + * @return bool + * + * @internal + */ + public function isModifiedModel() + { + return $this->modifiedModel; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Shape.php b/vendor/aws/aws-sdk-php/src/Api/Shape.php new file mode 100644 index 0000000..b1b8071 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Shape.php @@ -0,0 +1,77 @@ +<?php +namespace Aws\Api; + +/** + * Base class representing a modeled shape. + */ +class Shape extends AbstractModel +{ + /** + * Get a concrete shape for the given definition. + * + * @param array $definition + * @param ShapeMap $shapeMap + * + * @return mixed + * @throws \RuntimeException if the type is invalid + */ + public static function create(array $definition, ShapeMap $shapeMap) + { + static $map = [ + 'structure' => 'Aws\Api\StructureShape', + 'map' => 'Aws\Api\MapShape', + 'list' => 'Aws\Api\ListShape', + 'timestamp' => 'Aws\Api\TimestampShape', + 'integer' => 'Aws\Api\Shape', + 'double' => 'Aws\Api\Shape', + 'float' => 'Aws\Api\Shape', + 'long' => 'Aws\Api\Shape', + 'string' => 'Aws\Api\Shape', + 'byte' => 'Aws\Api\Shape', + 'character' => 'Aws\Api\Shape', + 'blob' => 'Aws\Api\Shape', + 'boolean' => 'Aws\Api\Shape' + ]; + + if (isset($definition['shape'])) { + return $shapeMap->resolve($definition); + } + + if (!isset($map[$definition['type']])) { + throw new \RuntimeException('Invalid type: ' + . print_r($definition, true)); + } + + $type = $map[$definition['type']]; + + return new $type($definition, $shapeMap); + } + + /** + * Get the type of the shape + * + * @return string + */ + public function getType() + { + return $this->definition['type']; + } + + /** + * Get the name of the shape + * + * @return string + */ + public function getName() + { + return $this->definition['name']; + } + + /** + * Get a context param definition. + */ + public function getContextParam() + { + return $this->contextParam; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/ShapeMap.php b/vendor/aws/aws-sdk-php/src/Api/ShapeMap.php new file mode 100644 index 0000000..b576e9b --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/ShapeMap.php @@ -0,0 +1,68 @@ +<?php +namespace Aws\Api; + +/** + * Builds shape based on shape references. + */ +class ShapeMap +{ + /** @var array */ + private $definitions; + + /** @var Shape[] */ + private $simple; + + /** + * @param array $shapeModels Associative array of shape definitions. + */ + public function __construct(array $shapeModels) + { + $this->definitions = $shapeModels; + } + + /** + * Get an array of shape names. + * + * @return array + */ + public function getShapeNames() + { + return array_keys($this->definitions); + } + + /** + * Resolve a shape reference + * + * @param array $shapeRef Shape reference shape + * + * @return Shape + * @throws \InvalidArgumentException + */ + public function resolve(array $shapeRef) + { + $shape = $shapeRef['shape']; + + if (!isset($this->definitions[$shape])) { + throw new \InvalidArgumentException('Shape not found: ' . $shape); + } + + $isSimple = count($shapeRef) == 1; + if ($isSimple && isset($this->simple[$shape])) { + return $this->simple[$shape]; + } + + $definition = $shapeRef + $this->definitions[$shape]; + $definition['name'] = $definition['shape']; + if (isset($definition['shape'])) { + unset($definition['shape']); + } + + $result = Shape::create($definition, $this); + + if ($isSimple) { + $this->simple[$shape] = $result; + } + + return $result; + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/StructureShape.php b/vendor/aws/aws-sdk-php/src/Api/StructureShape.php new file mode 100644 index 0000000..a287935 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/StructureShape.php @@ -0,0 +1,79 @@ +<?php +namespace Aws\Api; + +/** + * Represents a structure shape and resolve member shape references. + */ +class StructureShape extends Shape +{ + /** + * @var Shape[] + */ + private $members; + + public function __construct(array $definition, ShapeMap $shapeMap) + { + $definition['type'] = 'structure'; + + if (!isset($definition['members'])) { + $definition['members'] = []; + } + + parent::__construct($definition, $shapeMap); + } + + /** + * Gets a list of all members + * + * @return Shape[] + */ + public function getMembers() + { + if (empty($this->members)) { + $this->generateMembersHash(); + } + + return $this->members; + } + + /** + * Check if a specific member exists by name. + * + * @param string $name Name of the member to check + * + * @return bool + */ + public function hasMember($name) + { + return isset($this->definition['members'][$name]); + } + + /** + * Retrieve a member by name. + * + * @param string $name Name of the member to retrieve + * + * @return Shape + * @throws \InvalidArgumentException if the member is not found. + */ + public function getMember($name) + { + $members = $this->getMembers(); + + if (!isset($members[$name])) { + throw new \InvalidArgumentException('Unknown member ' . $name); + } + + return $members[$name]; + } + + + private function generateMembersHash() + { + $this->members = []; + + foreach ($this->definition['members'] as $name => $definition) { + $this->members[$name] = $this->shapeFor($definition); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/TimestampShape.php b/vendor/aws/aws-sdk-php/src/Api/TimestampShape.php new file mode 100644 index 0000000..7ef2646 --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/TimestampShape.php @@ -0,0 +1,48 @@ +<?php +namespace Aws\Api; + +/** + * Represents a timestamp shape. + */ +class TimestampShape extends Shape +{ + public function __construct(array $definition, ShapeMap $shapeMap) + { + $definition['type'] = 'timestamp'; + parent::__construct($definition, $shapeMap); + } + + /** + * Formats a timestamp value for a service. + * + * @param mixed $value Value to format + * @param string $format Format used to serialize the value + * + * @return int|string + * @throws \UnexpectedValueException if the format is unknown. + * @throws \InvalidArgumentException if the value is an unsupported type. + */ + public static function format($value, $format) + { + if ($value instanceof \DateTime) { + $value = $value->getTimestamp(); + } elseif (is_string($value)) { + $value = strtotime($value); + } elseif (!is_int($value)) { + throw new \InvalidArgumentException('Unable to handle the provided' + . ' timestamp type: ' . gettype($value)); + } + + switch ($format) { + case 'iso8601': + return gmdate('Y-m-d\TH:i:s\Z', $value); + case 'rfc822': + return gmdate('D, d M Y H:i:s \G\M\T', $value); + case 'unixTimestamp': + return $value; + default: + throw new \UnexpectedValueException('Unknown timestamp format: ' + . $format); + } + } +} diff --git a/vendor/aws/aws-sdk-php/src/Api/Validator.php b/vendor/aws/aws-sdk-php/src/Api/Validator.php new file mode 100644 index 0000000..a09aa2c --- /dev/null +++ b/vendor/aws/aws-sdk-php/src/Api/Validator.php @@ -0,0 +1,346 @@ +<?php +namespace Aws\Api; + +use Aws; + +/** + * Validates a schema against a hash of input. + */ +class Validator +{ + private $path = []; + private $errors = []; + private $constraints = []; + + private static $defaultConstraints = [ + 'required' => true, + 'min' => true, + 'max' => false, + 'pattern' => false + ]; + + /** + * @param array $constraints Associative array of constraints to enforce. + * Accepts the following keys: "required", "min", + * "max", and "pattern". If a key is not + * provided, the constraint will assume false. + */ + public function __construct(array $constraints = null) + { + static $assumedFalseValues = [ + 'required' => false, + 'min' => false, + 'max' => false, + 'pattern' => false + ]; + $this->constraints = empty($constraints) + ? self::$defaultConstraints + : $constraints + $assumedFalseValues; + } + + /** + * Validates the given input against the schema. + * + * @param string $name Operation name + * @param Shape $shape Shape to validate + * @param array $input Input to validate + * + * @throws \InvalidArgumentException if the input is invalid. + */ + public function validate($name, Shape $shape, array $input) + { + $this->dispatch($shape, $input); + + if ($this->errors) { + $message = sprintf( + "Found %d error%s while validating the input provided for the " + . "%s operation:\n%s", + count($this->errors), + count($this->errors) > 1 ? 's' : '', + $name, + implode("\n", $this->errors) + ); + $this->errors = []; + + throw new \InvalidArgumentException($message); + } + } + + private function dispatch(Shape $shape, $value) + { + static $methods = [ + 'structure' => 'check_structure', + 'list' => 'check_list', + 'map' => 'check_map', + 'blob' => 'check_blob', + 'boolean' => 'check_boolean', + 'integer' => 'check_numeric', + 'float' => 'check_numeric', + 'long' => 'check_numeric', + 'string' => 'check_string', + 'byte' => 'check_string', + 'char' => 'check_string' + ]; + + $type = $shape->getType(); + if (isset($methods[$type])) { + $this->{$methods[$type]}($shape, $value); + } + } + + private function check_structure(StructureShape $shape, $value) + { + $isDocument = (isset($shape['document']) && $shape['document']); + $isUnion = (isset($shape['union']) && $shape['union']); + if ($isDocument) { + if (!$this->checkDocumentType($value)) { + $this->addError("is not a valid document type"); + return; + } + } elseif ($isUnion) { + if (!$this->checkUnion($value)) { + $this->addError("is a union type and must have exactly one non null value"); + return; + } + } elseif (!$this->checkAssociativeArray($value)) { + return; + } + + if ($this->constraints['required'] && $shape['required']) { + foreach ($shape['required'] as $req) { + if (!isset($value[$req])) { + $this->path[] = $req; + $this->addError('is missing and is a required parameter'); + array_pop($this->path); + } + } + } + if (!$isDocument) { + foreach ($value as $name => $v) { + if ($shape->hasMember($name)) { + $this->path[] = $name; + $this->dispatch( + $shape->getMember($name), + isset($value[$name]) ? $value[$name] : null + ); + array_pop($this->path); + } + } + } + } + + private function check_list(ListShape $shape, $value) + { + if (!is_array($value)) { + $this->addError('must be an array. Found ' + . Aws\describe_type($value)); + return; + } + + $this->validateRange($shape, count($value), "list element count"); + + $items = $shape->getMember(); + foreach ($value as $index => $v) { + $this->path[] = $index; + $this->dispatch($items, $v); + array_pop($this->path); + } + } + + private function check_map(MapShape $shape, $value) + { + if (!$this->checkAssociativeArray($value)) { + return; + } + + $values = $shape->getValue(); + foreach ($value as $key => $v) { + $this->path[] = $key; + $this->dispatch($values, $v); + array_pop($this->path); + } + } + + private function check_blob(Shape $shape, $value) + { + static $valid = [ + 'string' => true, + 'integer' => true, + 'double' => true, + 'resource' => true + ]; + + $type = gettype($value); + if (!isset($valid[$type])) { + if ($type != 'object' || !method_exists($value, '__toString')) { + $this->addError('must be an fopen resource, a ' + . 'GuzzleHttp\Stream\StreamInterface object, or something ' + . 'that can be cast to a string. Found ' + . Aws\describe_type($value)); + } + } + } + + private function check_numeric(Shape $shape, $value) + { + if (!is_numeric($value)) { + $this->addError('must be numeric. Found ' + . Aws\describe_type($value)); + return; + } + + $this->validateRange($shape, $value, "numeric value"); + } + + private function check_boolean(Shape $shape, $value) + { + if (!is_bool($value)) { + $this->addError('must be a boolean. Found ' + . Aws\describe_type($value)); + } + } + + private function check_string(Shape $shape, $value) + { + if ($shape['jsonvalue']) { + if (!self::canJsonEncode($value)) { + $this->addError('must be a value encodable with \'json_encode\'.' + . ' Found ' . Aws\describe_type($value)); + } + return; + } + + if (!$this->checkCanString($value)) { + $this->addError('must be a string or an object that implements ' + . '__toString(). Found ' . Aws\describe_type($value)); + return; + } + + $value = isset($value) ? $value : ''; + $this->validateRange($shape, strlen($value), "string length"); + + if ($this->constraints['pattern']) { + $pattern = $shape['pattern']; + if ($pattern && !preg_match("/$pattern/", $value)) { + $this->addError("Pattern /$pattern/ failed to match '$value'"); + } + } + } + + private function validateRange(Shape $shape, $length, $descriptor) + { + if ($this->constraints['min']) { + $min = $shape['min']; + if ($min && $length < $min) { + $this->addError("expected $descriptor to be >= $min, but " + . "found $descriptor of $length"); + } + } + + if ($this->constraints['max']) { + $max = $shape['max']; + if ($max && $length > $max) { + $this->addError("expected $descriptor to be <= $max, but " + . "found $descriptor of $length"); + } + } + } + + private function checkArray($arr) + { + return $this->isIndexed($arr) || $this->isAssociative($arr); + } + + private function isAssociative($arr) + { + return count(array_filter(array_keys($arr), "is_string")) == count($arr); + } + + private function isIndexed(array $arr) + { + return $arr == array_values($arr); + } + + private function checkCanString($value) + { + static $valid = [ + 'string' => true, + 'integer' => true, + 'double' => true, + 'NULL' => true, + ]; + + $type = gettype($value); + + return isset($valid[$type]) || + ($type == 'object' && method_exists($value, '__toString')); + } + + private function checkAssociativeArray($value) + { + $isAssociative = false; + + if (is_array($value)) { + $expectedIndex = 0; + $key = key($value); + + do { + $isAssociative = $key !== $expectedIndex++; + next($value); + $key = key($value); + } while (!$isAssociative && null !== $key); + } + + if (!$isAssociative) { + $this->addError('must be an associative array. Found ' + . Aws\describe_type($value)); + return false; + } + + return true; + } + + private function checkDocumentType($value) + { + if (is_array($value)) { + $typeOfFirstKey = gettype(key($value)); + foreach ($value as $key => $val) { + if (!$this->checkDocumentType($val) || gettype($key) != $typeOfFirstKey) { + return false; + } + } + return $this->checkArray($value); + } + return is_null($value) + || is_numeric($value) + || is_string($value) + || is_bool($value); + } + + private function checkUnion($value) + { + if (is_array($value)) { + $nonNullCount = 0; + foreach ($value as $key => $val) { + if (!is_null($val) && !(strpos($key, "@") === 0)) { + $nonNullCount++; + } + } + return $nonNullCount == 1; + } + return !is_null($value); + } + + private function addError($message) + { + $this->errors[] = + implode('', array_map(function ($s) { return "[{$s}]"; }, $this->path)) + . ' ' + . $message; + } + + private function canJsonEncode($data) + { + return !is_resource($data); + } +} |