feat: add S3-compatible storage provider (MinIO, Ceph, R2, etc.)
Adds a new 'S3-Compatible Storage' provider that works with any
S3-API-compatible object storage service, including MinIO, Ceph,
Cloudflare R2, Backblaze B2, and others.
Changes:
- New provider class: classes/providers/storage/s3-compatible-provider.php
- Provider key: s3compatible
- Reads user-configured endpoint URL from settings
- Uses path-style URL access (required by most S3-compatible services)
- Supports credentials via AS3CF_S3COMPAT_ACCESS_KEY_ID /
AS3CF_S3COMPAT_SECRET_ACCESS_KEY wp-config.php constants
- Disables AWS-specific features (Block Public Access, Object Ownership)
- New provider SVG icons (s3compatible.svg, -link.svg, -round.svg)
- Registered provider in main plugin class with endpoint setting support
- Updated StorageProviderSubPage to show endpoint URL input for S3-compatible
- Built pro settings bundle with rollup (Svelte 4.2.19)
- Added package.json and updated rollup.config.mjs for pro-only builds
This commit is contained in:
75
vendor/Aws3/Aws/Api/AbstractModel.php
vendored
Normal file
75
vendor/Aws3/Aws/Api/AbstractModel.php
vendored
Normal file
@@ -0,0 +1,75 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
212
vendor/Aws3/Aws/Api/ApiProvider.php
vendored
Normal file
212
vendor/Aws3/Aws/Api/ApiProvider.php
vendored
Normal file
@@ -0,0 +1,212 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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', \DeliciousBrains\WP_Offload_Media\Aws3\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 \DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
}
|
||||
115
vendor/Aws3/Aws/Api/DateTimeResult.php
vendored
Normal file
115
vendor/Aws3/Aws/Api/DateTimeResult.php
vendored
Normal file
@@ -0,0 +1,115 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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
|
||||
{
|
||||
private const ISO8601_NANOSECOND_REGEX = '/^(.*\\.\\d{6})(\\d{1,3})(Z|[+-]\\d{2}:\\d{2})?$/';
|
||||
/**
|
||||
* 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');
|
||||
}
|
||||
// Prior to 8.0.10, nanosecond precision is not supported
|
||||
// Reduces to microsecond precision if nanosecond precision is detected
|
||||
if (\PHP_VERSION_ID < 80010 && \preg_match(self::ISO8601_NANOSECOND_REGEX, $iso8601Timestamp, $matches)) {
|
||||
$iso8601Timestamp = $matches[1] . ($matches[3] ?? '');
|
||||
}
|
||||
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 (\DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
107
vendor/Aws3/Aws/Api/DocModel.php
vendored
Normal file
107
vendor/Aws3/Aws/Api/DocModel.php
vendored
Normal file
@@ -0,0 +1,107 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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'])) {
|
||||
if (!isset($d['excludeAppend']) || !\in_array($parentName, $d['excludeAppend'])) {
|
||||
$result .= $d['append'];
|
||||
}
|
||||
}
|
||||
if (isset($d['appendOnly']) && \in_array($parentName, $d['appendOnly']['shapes'])) {
|
||||
$result .= $d['appendOnly']['message'];
|
||||
}
|
||||
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, 'clean' => \true, 'drop-proprietary-attributes' => \true, 'hide-comments' => \true, 'logical-emphasis' => \true]);
|
||||
$tidy->cleanRepair();
|
||||
return (string) $content;
|
||||
}
|
||||
}
|
||||
70
vendor/Aws3/Aws/Api/ErrorParser/AbstractErrorParser.php
vendored
Normal file
70
vendor/Aws3/Aws/Api/ErrorParser/AbstractErrorParser.php
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ErrorParser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\MetadataParserTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\PayloadParserTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
protected abstract 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;
|
||||
}
|
||||
}
|
||||
37
vendor/Aws3/Aws/Api/ErrorParser/JsonParserTrait.php
vendored
Normal file
37
vendor/Aws3/Aws/Api/ErrorParser/JsonParserTrait.php
vendored
Normal file
@@ -0,0 +1,37 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ErrorParser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\PayloadParserTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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 && !\is_null($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);
|
||||
}
|
||||
}
|
||||
}
|
||||
38
vendor/Aws3/Aws/Api/ErrorParser/JsonRpcErrorParser.php
vendored
Normal file
38
vendor/Aws3/Aws/Api/ErrorParser/JsonRpcErrorParser.php
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ErrorParser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\JsonParser;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
43
vendor/Aws3/Aws/Api/ErrorParser/RestJsonErrorParser.php
vendored
Normal file
43
vendor/Aws3/Aws/Api/ErrorParser/RestJsonErrorParser.php
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ErrorParser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\JsonParser;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
82
vendor/Aws3/Aws/Api/ErrorParser/XmlErrorParser.php
vendored
Normal file
82
vendor/Aws3/Aws/Api/ErrorParser/XmlErrorParser.php
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ErrorParser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\PayloadParserTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\XmlParser;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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]);
|
||||
}
|
||||
}
|
||||
}
|
||||
30
vendor/Aws3/Aws/Api/ListShape.php
vendored
Normal file
30
vendor/Aws3/Aws/Api/ListShape.php
vendored
Normal file
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
43
vendor/Aws3/Aws/Api/MapShape.php
vendored
Normal file
43
vendor/Aws3/Aws/Api/MapShape.php
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
124
vendor/Aws3/Aws/Api/Operation.php
vendored
Normal file
124
vendor/Aws3/Aws/Api/Operation.php
vendored
Normal file
@@ -0,0 +1,124 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
35
vendor/Aws3/Aws/Api/Parser/AbstractParser.php
vendored
Normal file
35
vendor/Aws3/Aws/Api/Parser/AbstractParser.php
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\ResultInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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
|
||||
*/
|
||||
public abstract function __invoke(CommandInterface $command, ResponseInterface $response);
|
||||
public abstract function parseMemberFromStream(StreamInterface $stream, StructureShape $member, $response);
|
||||
}
|
||||
140
vendor/Aws3/Aws/Api/Parser/AbstractRestParser.php
vendored
Normal file
140
vendor/Aws3/Aws/Api/Parser/AbstractRestParser.php
vendored
Normal file
@@ -0,0 +1,140 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\DateTimeResult;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Result;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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
|
||||
*/
|
||||
protected abstract 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();
|
||||
}
|
||||
}
|
||||
38
vendor/Aws3/Aws/Api/Parser/Crc32ValidatingParser.php
vendored
Normal file
38
vendor/Aws3/Aws/Api/Parser/Crc32ValidatingParser.php
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Exception\AwsException;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\StreamInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
251
vendor/Aws3/Aws/Api/Parser/DecodingEventStreamIterator.php
vendored
Normal file
251
vendor/Aws3/Aws/Api/Parser/DecodingEventStreamIterator.php
vendored
Normal file
@@ -0,0 +1,251 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use Iterator;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\DateTimeResult;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\StreamInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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. */
|
||||
protected $stream;
|
||||
/** @var array Currently parsed event. */
|
||||
protected $currentEvent;
|
||||
/** @var int Current in-order event key. */
|
||||
protected $key;
|
||||
/** @var resource|\HashContext CRC32 hash context for event validation */
|
||||
protected $hashContext;
|
||||
/** @var int $currentPosition */
|
||||
protected $currentPosition;
|
||||
/**
|
||||
* DecodingEventStreamIterator constructor.
|
||||
*
|
||||
* @param StreamInterface $stream
|
||||
*/
|
||||
public function __construct(StreamInterface $stream)
|
||||
{
|
||||
$this->stream = $stream;
|
||||
$this->rewind();
|
||||
}
|
||||
protected 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];
|
||||
}
|
||||
protected 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];
|
||||
}
|
||||
/**
|
||||
* This method decodes an event from the stream.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected 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
|
||||
protected 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];
|
||||
}
|
||||
}
|
||||
143
vendor/Aws3/Aws/Api/Parser/EventParsingIterator.php
vendored
Normal file
143
vendor/Aws3/Aws/Api/Parser/EventParsingIterator.php
vendored
Normal file
@@ -0,0 +1,143 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use Iterator;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Exception\EventStreamDataException;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception\ParserException;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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 = $this->chooseDecodingIterator($stream);
|
||||
$this->shape = $shape;
|
||||
$this->parser = $parser;
|
||||
}
|
||||
/**
|
||||
* This method choose a decoding iterator implementation based on if the stream
|
||||
* is seekable or not.
|
||||
*
|
||||
* @param $stream
|
||||
*
|
||||
* @return Iterator
|
||||
*/
|
||||
private function chooseDecodingIterator($stream)
|
||||
{
|
||||
if ($stream->isSeekable()) {
|
||||
return new DecodingEventStreamIterator($stream);
|
||||
} else {
|
||||
return new NonSeekableStreamDecodingEventStreamIterator($stream);
|
||||
}
|
||||
}
|
||||
#[\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.');
|
||||
}
|
||||
}
|
||||
$eventType = $event['headers'][':event-type'] ?? null;
|
||||
if (empty($eventType)) {
|
||||
throw new ParserException('Failed to parse without event type.');
|
||||
}
|
||||
$eventPayload = $event['payload'];
|
||||
if ($eventType === 'initial-response') {
|
||||
return $this->parseInitialResponseEvent($eventPayload);
|
||||
}
|
||||
$eventShape = $this->shape->getMember($eventType);
|
||||
return [$eventType => \array_merge($this->parseEventHeaders($event['headers'], $eventShape), $this->parseEventPayload($eventPayload, $eventShape))];
|
||||
}
|
||||
/**
|
||||
* @param $headers
|
||||
* @param $eventShape
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private function parseEventHeaders($headers, $eventShape) : array
|
||||
{
|
||||
$parsedHeaders = [];
|
||||
foreach ($eventShape->getMembers() as $memberName => $memberProps) {
|
||||
if (isset($memberProps['eventheader'])) {
|
||||
$parsedHeaders[$memberName] = $headers[$memberName];
|
||||
}
|
||||
}
|
||||
return $parsedHeaders;
|
||||
}
|
||||
/**
|
||||
* @param $payload
|
||||
* @param $eventShape
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private function parseEventPayload($payload, $eventShape) : array
|
||||
{
|
||||
$parsedPayload = [];
|
||||
foreach ($eventShape->getMembers() as $memberName => $memberProps) {
|
||||
$memberShape = $eventShape->getMember($memberName);
|
||||
if (isset($memberProps['eventpayload'])) {
|
||||
if ($memberShape->getType() === 'blob') {
|
||||
$parsedPayload[$memberName] = $payload;
|
||||
} else {
|
||||
$parsedPayload[$memberName] = $this->parser->parseMemberFromStream($payload, $memberShape, null);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (empty($parsedPayload) && !empty($payload->getContents())) {
|
||||
/**
|
||||
* If we did not find a member with an eventpayload trait, then we should deserialize the payload
|
||||
* using the event's shape.
|
||||
*/
|
||||
$parsedPayload = $this->parser->parseMemberFromStream($payload, $eventShape, null);
|
||||
}
|
||||
return $parsedPayload;
|
||||
}
|
||||
private function parseError(array $event)
|
||||
{
|
||||
throw new EventStreamDataException($event['headers'][':error-code'], $event['headers'][':error-message']);
|
||||
}
|
||||
private function parseInitialResponseEvent($payload) : array
|
||||
{
|
||||
return ['initial-response' => \json_decode($payload, \true)];
|
||||
}
|
||||
}
|
||||
49
vendor/Aws3/Aws/Api/Parser/Exception/ParserException.php
vendored
Normal file
49
vendor/Aws3/Aws/Api/Parser/Exception/ParserException.php
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\HasMonitoringEventsTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\MonitoringEventsInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\ResponseContainerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
57
vendor/Aws3/Aws/Api/Parser/JsonParser.php
vendored
Normal file
57
vendor/Aws3/Aws/Api/Parser/JsonParser.php
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\DateTimeResult;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
}
|
||||
59
vendor/Aws3/Aws/Api/Parser/JsonRpcParser.php
vendored
Normal file
59
vendor/Aws3/Aws/Api/Parser/JsonRpcParser.php
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Operation;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Result;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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());
|
||||
return $this->parseResponse($response, $operation);
|
||||
}
|
||||
/**
|
||||
* This method parses a response based on JSON RPC protocol.
|
||||
*
|
||||
* @param ResponseInterface $response the response to parse.
|
||||
* @param Operation $operation the operation which holds information for
|
||||
* parsing the response.
|
||||
*
|
||||
* @return Result
|
||||
*/
|
||||
private function parseResponse(ResponseInterface $response, Operation $operation)
|
||||
{
|
||||
if (null === $operation['output']) {
|
||||
return new Result([]);
|
||||
}
|
||||
$outputShape = $operation->getOutput();
|
||||
foreach ($outputShape->getMembers() as $memberName => $memberProps) {
|
||||
if (!empty($memberProps['eventstream'])) {
|
||||
return new Result([$memberName => new EventParsingIterator($response->getBody(), $outputShape->getMember($memberName), $this)]);
|
||||
}
|
||||
}
|
||||
$result = $this->parseMemberFromStream($response->getBody(), $operation->getOutput(), $response);
|
||||
return new Result(\is_null($result) ? [] : $result);
|
||||
}
|
||||
public function parseMemberFromStream(StreamInterface $stream, StructureShape $member, $response)
|
||||
{
|
||||
return $this->parser->parse($member, $this->parseJson($stream, $response));
|
||||
}
|
||||
}
|
||||
71
vendor/Aws3/Aws/Api/Parser/MetadataParserTrait.php
vendored
Normal file
71
vendor/Aws3/Aws/Api/Parser/MetadataParserTrait.php
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\DateTimeResult;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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();
|
||||
}
|
||||
}
|
||||
81
vendor/Aws3/Aws/Api/Parser/NonSeekableStreamDecodingEventStreamIterator.php
vendored
Normal file
81
vendor/Aws3/Aws/Api/Parser/NonSeekableStreamDecodingEventStreamIterator.php
vendored
Normal file
@@ -0,0 +1,81 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\StreamInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception\ParserException;
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
class NonSeekableStreamDecodingEventStreamIterator extends DecodingEventStreamIterator
|
||||
{
|
||||
/** @var array $tempBuffer */
|
||||
private $tempBuffer;
|
||||
/**
|
||||
* NonSeekableStreamDecodingEventStreamIterator constructor.
|
||||
*
|
||||
* @param StreamInterface $stream
|
||||
*/
|
||||
public function __construct(StreamInterface $stream)
|
||||
{
|
||||
$this->stream = $stream;
|
||||
if ($this->stream->isSeekable()) {
|
||||
throw new \InvalidArgumentException('The stream provided must be not seekable.');
|
||||
}
|
||||
$this->tempBuffer = [];
|
||||
}
|
||||
/**
|
||||
* @inheritDoc
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function parseEvent() : array
|
||||
{
|
||||
$event = [];
|
||||
$this->hashContext = \hash_init('crc32b');
|
||||
$prelude = $this->parsePrelude()[0];
|
||||
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;
|
||||
}
|
||||
protected function readAndHashBytes($num) : string
|
||||
{
|
||||
$bytes = '';
|
||||
while (!empty($this->tempBuffer) && $num > 0) {
|
||||
$byte = \array_shift($this->tempBuffer);
|
||||
$bytes .= $byte;
|
||||
$num = $num - 1;
|
||||
}
|
||||
$bytes = $bytes . $this->stream->read($num);
|
||||
\hash_update($this->hashContext, $bytes);
|
||||
return $bytes;
|
||||
}
|
||||
// Iterator Functionality
|
||||
#[\ReturnTypeWillChange]
|
||||
public function rewind()
|
||||
{
|
||||
$this->currentEvent = $this->parseEvent();
|
||||
}
|
||||
public function next()
|
||||
{
|
||||
$this->tempBuffer[] = $this->stream->read(1);
|
||||
if ($this->valid()) {
|
||||
$this->key++;
|
||||
$this->currentEvent = $this->parseEvent();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @return bool
|
||||
*/
|
||||
#[\ReturnTypeWillChange]
|
||||
public function valid()
|
||||
{
|
||||
return !$this->stream->eof();
|
||||
}
|
||||
}
|
||||
47
vendor/Aws3/Aws/Api/Parser/PayloadParserTrait.php
vendored
Normal file
47
vendor/Aws3/Aws/Api/Parser/PayloadParserTrait.php
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception\ParserException;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
46
vendor/Aws3/Aws/Api/Parser/QueryParser.php
vendored
Normal file
46
vendor/Aws3/Aws/Api/Parser/QueryParser.php
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Result;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
39
vendor/Aws3/Aws/Api/Parser/RestJsonParser.php
vendored
Normal file
39
vendor/Aws3/Aws/Api/Parser/RestJsonParser.php
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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 [];
|
||||
}
|
||||
}
|
||||
33
vendor/Aws3/Aws/Api/Parser/RestXmlParser.php
vendored
Normal file
33
vendor/Aws3/Aws/Api/Parser/RestXmlParser.php
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\ResponseInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
125
vendor/Aws3/Aws/Api/Parser/XmlParser.php
vendored
Normal file
125
vendor/Aws3/Aws/Api/Parser/XmlParser.php
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\DateTimeResult;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ListShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\MapShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception\ParserException;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
30
vendor/Aws3/Aws/Api/Serializer/Ec2ParamBuilder.php
vendored
Normal file
30
vendor/Aws3/Aws/Api/Serializer/Ec2ParamBuilder.php
vendored
Normal file
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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 (!empty($value)) {
|
||||
$items = $shape->getMember();
|
||||
foreach ($value as $k => $v) {
|
||||
$this->format($items, $v, $prefix . '.' . ($k + 1), $query);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
94
vendor/Aws3/Aws/Api/Serializer/JsonBody.php
vendored
Normal file
94
vendor/Aws3/Aws/Api/Serializer/JsonBody.php
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\TimestampShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
}
|
||||
59
vendor/Aws3/Aws/Api/Serializer/JsonRpcSerializer.php
vendored
Normal file
59
vendor/Aws3/Aws/Api/Serializer/JsonRpcSerializer.php
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\EndpointV2SerializerTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\Ruleset\RulesetEndpoint;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\Request;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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, $endpoint = 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 ($endpoint instanceof RulesetEndpoint) {
|
||||
$this->setEndpointV2RequestOptions($endpoint, $headers);
|
||||
}
|
||||
return new Request($operation['http']['method'], $this->endpoint, $headers, $this->jsonFormatter->build($operation->getInput(), $commandArgs));
|
||||
}
|
||||
}
|
||||
112
vendor/Aws3/Aws/Api/Serializer/QueryParamBuilder.php
vendored
Normal file
112
vendor/Aws3/Aws/Api/Serializer/QueryParamBuilder.php
vendored
Normal file
@@ -0,0 +1,112 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ListShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\MapShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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';
|
||||
}
|
||||
}
|
||||
54
vendor/Aws3/Aws/Api/Serializer/QuerySerializer.php
vendored
Normal file
54
vendor/Aws3/Aws/Api/Serializer/QuerySerializer.php
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\EndpointProviderV2;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\EndpointV2SerializerTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\Ruleset\RulesetEndpoint;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\Request;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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, $endpoint = 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 ($endpoint instanceof RulesetEndpoint) {
|
||||
$this->setEndpointV2RequestOptions($endpoint, $headers);
|
||||
}
|
||||
return new Request('POST', $this->endpoint, $headers, $body);
|
||||
}
|
||||
}
|
||||
34
vendor/Aws3/Aws/Api/Serializer/RestJsonSerializer.php
vendored
Normal file
34
vendor/Aws3/Aws/Api/Serializer/RestJsonSerializer.php
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
239
vendor/Aws3/Aws/Api/Serializer/RestSerializer.php
vendored
Normal file
239
vendor/Aws3/Aws/Api/Serializer/RestSerializer.php
vendored
Normal file
@@ -0,0 +1,239 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\MapShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Operation;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\TimestampShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\EndpointProviderV2;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\EndpointV2SerializerTrait;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\EndpointV2\Ruleset\RulesetEndpoint;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\Request;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\Uri;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\UriResolver;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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, $endpoint = null)
|
||||
{
|
||||
$operation = $this->api->getOperation($command->getName());
|
||||
$commandArgs = $command->toArray();
|
||||
$opts = $this->serialize($operation, $commandArgs);
|
||||
$headers = isset($opts['headers']) ? $opts['headers'] : [];
|
||||
if ($endpoint instanceof RulesetEndpoint) {
|
||||
$this->setEndpointV2RequestOptions($endpoint, $headers);
|
||||
}
|
||||
$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.
|
||||
*/
|
||||
protected abstract 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 (\strpos($relative, '../') !== \false || \substr($relative, -2) === '..') {
|
||||
if ($relative[0] !== '/') {
|
||||
$relative = '/' . $relative;
|
||||
}
|
||||
return new Uri($this->endpoint->withPath('') . $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;
|
||||
}
|
||||
}
|
||||
42
vendor/Aws3/Aws/Api/Serializer/RestXmlSerializer.php
vendored
Normal file
42
vendor/Aws3/Aws/Api/Serializer/RestXmlSerializer.php
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
148
vendor/Aws3/Aws/Api/Serializer/XmlBody.php
vendored
Normal file
148
vendor/Aws3/Aws/Api/Serializer/XmlBody.php
vendored
Normal file
@@ -0,0 +1,148 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Serializer;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\MapShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Service;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Shape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\ListShape;
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
}
|
||||
416
vendor/Aws3/Aws/Api/Service.php
vendored
Normal file
416
vendor/Aws3/Aws/Api/Service.php
vendored
Normal file
@@ -0,0 +1,416 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api;
|
||||
|
||||
/**
|
||||
* 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' => Serializer\JsonRpcSerializer::class, 'query' => Serializer\QuerySerializer::class, 'rest-json' => Serializer\RestJsonSerializer::class, 'rest-xml' => Serializer\RestXmlSerializer::class];
|
||||
$proto = $api->getProtocol();
|
||||
if (isset($mapping[$proto])) {
|
||||
return new $mapping[$proto]($api, $endpoint);
|
||||
}
|
||||
if ($proto == 'ec2') {
|
||||
return new Serializer\QuerySerializer($api, $endpoint, new Serializer\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' => ErrorParser\JsonRpcErrorParser::class, 'query' => ErrorParser\XmlErrorParser::class, 'rest-json' => ErrorParser\RestJsonErrorParser::class, 'rest-xml' => ErrorParser\XmlErrorParser::class, 'ec2' => ErrorParser\XmlErrorParser::class];
|
||||
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' => Parser\JsonRpcParser::class, 'query' => Parser\QueryParser::class, 'rest-json' => Parser\RestJsonParser::class, 'rest-xml' => Parser\RestXmlParser::class];
|
||||
$proto = $api->getProtocol();
|
||||
if (isset($mapping[$proto])) {
|
||||
return new $mapping[$proto]($api);
|
||||
}
|
||||
if ($proto == 'ec2') {
|
||||
return new Parser\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);
|
||||
} elseif ($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->shapeMap = new ShapeMap($definition['shapes']);
|
||||
$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;
|
||||
}
|
||||
}
|
||||
56
vendor/Aws3/Aws/Api/Shape.php
vendored
Normal file
56
vendor/Aws3/Aws/Api/Shape.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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' => StructureShape::class, 'map' => MapShape::class, 'list' => ListShape::class, 'timestamp' => TimestampShape::class, 'integer' => Shape::class, 'double' => Shape::class, 'float' => Shape::class, 'long' => Shape::class, 'string' => Shape::class, 'byte' => Shape::class, 'character' => Shape::class, 'blob' => Shape::class, 'boolean' => Shape::class];
|
||||
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;
|
||||
}
|
||||
}
|
||||
59
vendor/Aws3/Aws/Api/ShapeMap.php
vendored
Normal file
59
vendor/Aws3/Aws/Api/ShapeMap.php
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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;
|
||||
}
|
||||
}
|
||||
68
vendor/Aws3/Aws/Api/StructureShape.php
vendored
Normal file
68
vendor/Aws3/Aws/Api/StructureShape.php
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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);
|
||||
}
|
||||
}
|
||||
}
|
||||
45
vendor/Aws3/Aws/Api/TimestampShape.php
vendored
Normal file
45
vendor/Aws3/Aws/Api/TimestampShape.php
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\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 \DateTimeInterface) {
|
||||
$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);
|
||||
}
|
||||
}
|
||||
}
|
||||
246
vendor/Aws3/Aws/Api/Validator.php
vendored
Normal file
246
vendor/Aws3/Aws/Api/Validator.php
vendored
Normal file
@@ -0,0 +1,246 @@
|
||||
<?php
|
||||
|
||||
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Aws3\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 ' . 'DeliciousBrains\\WP_Offload_Media\\Aws3\\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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user