installed plugin Infinite Uploads version 2.0.8
This commit is contained in:
Gitium
254
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/AbstractUploadManager.php
vendored
Normal file
254
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/AbstractUploadManager.php
vendored
Normal file
@ -0,0 +1,254 @@
|
||||
<?php
|
||||
|
||||
namespace UglyRobot\Infinite_Uploads\Aws\Multipart;
|
||||
|
||||
use UglyRobot\Infinite_Uploads\Aws\AwsClientInterface as Client;
|
||||
use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
|
||||
use UglyRobot\Infinite_Uploads\Aws\CommandPool;
|
||||
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
|
||||
use UglyRobot\Infinite_Uploads\Aws\Exception\MultipartUploadException;
|
||||
use UglyRobot\Infinite_Uploads\Aws\Result;
|
||||
use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
|
||||
use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
|
||||
use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
|
||||
use InvalidArgumentException as IAE;
|
||||
use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
|
||||
/**
|
||||
* Encapsulates the execution of a multipart upload to S3 or Glacier.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
abstract class AbstractUploadManager implements \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromisorInterface
|
||||
{
|
||||
const DEFAULT_CONCURRENCY = 5;
|
||||
/** @var array Default values for base multipart configuration */
|
||||
private static $defaultConfig = ['part_size' => null, 'state' => null, 'concurrency' => self::DEFAULT_CONCURRENCY, 'prepare_data_source' => null, 'before_initiate' => null, 'before_upload' => null, 'before_complete' => null, 'exception_class' => 'UglyRobot\\Infinite_Uploads\\Aws\\Exception\\MultipartUploadException'];
|
||||
/** @var Client Client used for the upload. */
|
||||
protected $client;
|
||||
/** @var array Configuration used to perform the upload. */
|
||||
protected $config;
|
||||
/** @var array Service-specific information about the upload workflow. */
|
||||
protected $info;
|
||||
/** @var PromiseInterface Promise that represents the multipart upload. */
|
||||
protected $promise;
|
||||
/** @var UploadState State used to manage the upload. */
|
||||
protected $state;
|
||||
/**
|
||||
* @param Client $client
|
||||
* @param array $config
|
||||
*/
|
||||
public function __construct(\UglyRobot\Infinite_Uploads\Aws\AwsClientInterface $client, array $config = [])
|
||||
{
|
||||
$this->client = $client;
|
||||
$this->info = $this->loadUploadWorkflowInfo();
|
||||
$this->config = $config + self::$defaultConfig;
|
||||
$this->state = $this->determineState();
|
||||
}
|
||||
/**
|
||||
* Returns the current state of the upload
|
||||
*
|
||||
* @return UploadState
|
||||
*/
|
||||
public function getState()
|
||||
{
|
||||
return $this->state;
|
||||
}
|
||||
/**
|
||||
* Upload the source using multipart upload operations.
|
||||
*
|
||||
* @return Result The result of the CompleteMultipartUpload operation.
|
||||
* @throws \LogicException if the upload is already complete or aborted.
|
||||
* @throws MultipartUploadException if an upload operation fails.
|
||||
*/
|
||||
public function upload()
|
||||
{
|
||||
return $this->promise()->wait();
|
||||
}
|
||||
/**
|
||||
* Upload the source asynchronously using multipart upload operations.
|
||||
*
|
||||
* @return PromiseInterface
|
||||
*/
|
||||
public function promise()
|
||||
{
|
||||
if ($this->promise) {
|
||||
return $this->promise;
|
||||
}
|
||||
return $this->promise = \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\coroutine(function () {
|
||||
// Initiate the upload.
|
||||
if ($this->state->isCompleted()) {
|
||||
throw new \LogicException('This multipart upload has already ' . 'been completed or aborted.');
|
||||
}
|
||||
if (!$this->state->isInitiated()) {
|
||||
// Execute the prepare callback.
|
||||
if (is_callable($this->config["prepare_data_source"])) {
|
||||
$this->config["prepare_data_source"]();
|
||||
}
|
||||
$result = (yield $this->execCommand('initiate', $this->getInitiateParams()));
|
||||
$this->state->setUploadId($this->info['id']['upload_id'], $result[$this->info['id']['upload_id']]);
|
||||
$this->state->setStatus(\UglyRobot\Infinite_Uploads\Aws\Multipart\UploadState::INITIATED);
|
||||
}
|
||||
// Create a command pool from a generator that yields UploadPart
|
||||
// commands for each upload part.
|
||||
$resultHandler = $this->getResultHandler($errors);
|
||||
$commands = new \UglyRobot\Infinite_Uploads\Aws\CommandPool($this->client, $this->getUploadCommands($resultHandler), ['concurrency' => $this->config['concurrency'], 'before' => $this->config['before_upload']]);
|
||||
// Execute the pool of commands concurrently, and process errors.
|
||||
(yield $commands->promise());
|
||||
if ($errors) {
|
||||
throw new $this->config['exception_class']($this->state, $errors);
|
||||
}
|
||||
// Complete the multipart upload.
|
||||
(yield $this->execCommand('complete', $this->getCompleteParams()));
|
||||
$this->state->setStatus(\UglyRobot\Infinite_Uploads\Aws\Multipart\UploadState::COMPLETED);
|
||||
})->otherwise($this->buildFailureCatch());
|
||||
}
|
||||
private function transformException($e)
|
||||
{
|
||||
// Throw errors from the operations as a specific Multipart error.
|
||||
if ($e instanceof AwsException) {
|
||||
$e = new $this->config['exception_class']($this->state, $e);
|
||||
}
|
||||
throw $e;
|
||||
}
|
||||
private function buildFailureCatch()
|
||||
{
|
||||
if (interface_exists("Throwable")) {
|
||||
return function (\Throwable $e) {
|
||||
return $this->transformException($e);
|
||||
};
|
||||
} else {
|
||||
return function (\Exception $e) {
|
||||
return $this->transformException($e);
|
||||
};
|
||||
}
|
||||
}
|
||||
protected function getConfig()
|
||||
{
|
||||
return $this->config;
|
||||
}
|
||||
/**
|
||||
* Provides service-specific information about the multipart upload
|
||||
* workflow.
|
||||
*
|
||||
* This array of data should include the keys: 'command', 'id', and 'part_num'.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected abstract function loadUploadWorkflowInfo();
|
||||
/**
|
||||
* Determines the part size to use for upload parts.
|
||||
*
|
||||
* Examines the provided partSize value and the source to determine the
|
||||
* best possible part size.
|
||||
*
|
||||
* @throws \InvalidArgumentException if the part size is invalid.
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
protected abstract function determinePartSize();
|
||||
/**
|
||||
* Uses information from the Command and Result to determine which part was
|
||||
* uploaded and mark it as uploaded in the upload's state.
|
||||
*
|
||||
* @param CommandInterface $command
|
||||
* @param ResultInterface $result
|
||||
*/
|
||||
protected abstract function handleResult(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Aws\ResultInterface $result);
|
||||
/**
|
||||
* Gets the service-specific parameters used to initiate the upload.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected abstract function getInitiateParams();
|
||||
/**
|
||||
* Gets the service-specific parameters used to complete the upload.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected abstract function getCompleteParams();
|
||||
/**
|
||||
* Based on the config and service-specific workflow info, creates a
|
||||
* `Promise` for an `UploadState` object.
|
||||
*
|
||||
* @return PromiseInterface A `Promise` that resolves to an `UploadState`.
|
||||
*/
|
||||
private function determineState()
|
||||
{
|
||||
// If the state was provided via config, then just use it.
|
||||
if ($this->config['state'] instanceof UploadState) {
|
||||
return $this->config['state'];
|
||||
}
|
||||
// Otherwise, construct a new state from the provided identifiers.
|
||||
$required = $this->info['id'];
|
||||
$id = [$required['upload_id'] => null];
|
||||
unset($required['upload_id']);
|
||||
foreach ($required as $key => $param) {
|
||||
if (!$this->config[$key]) {
|
||||
throw new \InvalidArgumentException('You must provide a value for "' . $key . '" in ' . 'your config for the MultipartUploader for ' . $this->client->getApi()->getServiceFullName() . '.');
|
||||
}
|
||||
$id[$param] = $this->config[$key];
|
||||
}
|
||||
$state = new \UglyRobot\Infinite_Uploads\Aws\Multipart\UploadState($id);
|
||||
$state->setPartSize($this->determinePartSize());
|
||||
return $state;
|
||||
}
|
||||
/**
|
||||
* Executes a MUP command with all of the parameters for the operation.
|
||||
*
|
||||
* @param string $operation Name of the operation.
|
||||
* @param array $params Service-specific params for the operation.
|
||||
*
|
||||
* @return PromiseInterface
|
||||
*/
|
||||
protected function execCommand($operation, array $params)
|
||||
{
|
||||
// Create the command.
|
||||
$command = $this->client->getCommand($this->info['command'][$operation], $params + $this->state->getId());
|
||||
// Execute the before callback.
|
||||
if (is_callable($this->config["before_{$operation}"])) {
|
||||
$this->config["before_{$operation}"]($command);
|
||||
}
|
||||
// Execute the command asynchronously and return the promise.
|
||||
return $this->client->executeAsync($command);
|
||||
}
|
||||
/**
|
||||
* Returns a middleware for processing responses of part upload operations.
|
||||
*
|
||||
* - Adds an onFulfilled callback that calls the service-specific
|
||||
* handleResult method on the Result of the operation.
|
||||
* - Adds an onRejected callback that adds the error to an array of errors.
|
||||
* - Has a passedByRef $errors arg that the exceptions get added to. The
|
||||
* caller should use that &$errors array to do error handling.
|
||||
*
|
||||
* @param array $errors Errors from upload operations are added to this.
|
||||
*
|
||||
* @return callable
|
||||
*/
|
||||
protected function getResultHandler(&$errors = [])
|
||||
{
|
||||
return function (callable $handler) use(&$errors) {
|
||||
return function (\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request = null) use($handler, &$errors) {
|
||||
return $handler($command, $request)->then(function (\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result) use($command) {
|
||||
$this->handleResult($command, $result);
|
||||
return $result;
|
||||
}, function (\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e) use(&$errors) {
|
||||
$errors[$e->getCommand()[$this->info['part_num']]] = $e;
|
||||
return new \UglyRobot\Infinite_Uploads\Aws\Result();
|
||||
});
|
||||
};
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Creates a generator that yields part data for the upload's source.
|
||||
*
|
||||
* Yields associative arrays of parameters that are ultimately merged in
|
||||
* with others to form the complete parameters of a command. This can
|
||||
* include the Body parameter, which is a limited stream (i.e., a Stream
|
||||
* object, decorated with a LimitStream).
|
||||
*
|
||||
* @param callable $resultHandler
|
||||
*
|
||||
* @return \Generator
|
||||
*/
|
||||
protected abstract function getUploadCommands(callable $resultHandler);
|
||||
}
|
||||
118
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/AbstractUploader.php
vendored
Normal file
118
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/AbstractUploader.php
vendored
Normal file
@ -0,0 +1,118 @@
|
||||
<?php
|
||||
|
||||
namespace UglyRobot\Infinite_Uploads\Aws\Multipart;
|
||||
|
||||
use UglyRobot\Infinite_Uploads\Aws\AwsClientInterface as Client;
|
||||
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
|
||||
use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
|
||||
use InvalidArgumentException as IAE;
|
||||
use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface as Stream;
|
||||
abstract class AbstractUploader extends \UglyRobot\Infinite_Uploads\Aws\Multipart\AbstractUploadManager
|
||||
{
|
||||
/** @var Stream Source of the data to be uploaded. */
|
||||
protected $source;
|
||||
/**
|
||||
* @param Client $client
|
||||
* @param mixed $source
|
||||
* @param array $config
|
||||
*/
|
||||
public function __construct(\UglyRobot\Infinite_Uploads\Aws\AwsClientInterface $client, $source, array $config = [])
|
||||
{
|
||||
$this->source = $this->determineSource($source);
|
||||
parent::__construct($client, $config);
|
||||
}
|
||||
/**
|
||||
* Create a stream for a part that starts at the current position and
|
||||
* has a length of the upload part size (or less with the final part).
|
||||
*
|
||||
* @param Stream $stream
|
||||
*
|
||||
* @return Psr7\LimitStream
|
||||
*/
|
||||
protected function limitPartStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream)
|
||||
{
|
||||
// Limit what is read from the stream to the part size.
|
||||
return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream($stream, $this->state->getPartSize(), $this->source->tell());
|
||||
}
|
||||
protected function getUploadCommands(callable $resultHandler)
|
||||
{
|
||||
// Determine if the source can be seeked.
|
||||
$seekable = $this->source->isSeekable() && $this->source->getMetadata('wrapper_type') === 'plainfile';
|
||||
for ($partNumber = 1; $this->isEof($seekable); $partNumber++) {
|
||||
// If we haven't already uploaded this part, yield a new part.
|
||||
if (!$this->state->hasPartBeenUploaded($partNumber)) {
|
||||
$partStartPos = $this->source->tell();
|
||||
if (!($data = $this->createPart($seekable, $partNumber))) {
|
||||
break;
|
||||
}
|
||||
$command = $this->client->getCommand($this->info['command']['upload'], $data + $this->state->getId());
|
||||
$command->getHandlerList()->appendSign($resultHandler, 'mup');
|
||||
$numberOfParts = $this->getNumberOfParts($this->state->getPartSize());
|
||||
if (isset($numberOfParts) && $partNumber > $numberOfParts) {
|
||||
throw new $this->config['exception_class']($this->state, new \UglyRobot\Infinite_Uploads\Aws\Exception\AwsException("Maximum part number for this job exceeded, file has likely been corrupted." . " Please restart this upload.", $command));
|
||||
}
|
||||
(yield $command);
|
||||
if ($this->source->tell() > $partStartPos) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// Advance the source's offset if not already advanced.
|
||||
if ($seekable) {
|
||||
$this->source->seek(min($this->source->tell() + $this->state->getPartSize(), $this->source->getSize()));
|
||||
} else {
|
||||
$this->source->read($this->state->getPartSize());
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Generates the parameters for an upload part by analyzing a range of the
|
||||
* source starting from the current offset up to the part size.
|
||||
*
|
||||
* @param bool $seekable
|
||||
* @param int $number
|
||||
*
|
||||
* @return array|null
|
||||
*/
|
||||
protected abstract function createPart($seekable, $number);
|
||||
/**
|
||||
* Checks if the source is at EOF.
|
||||
*
|
||||
* @param bool $seekable
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private function isEof($seekable)
|
||||
{
|
||||
return $seekable ? $this->source->tell() < $this->source->getSize() : !$this->source->eof();
|
||||
}
|
||||
/**
|
||||
* Turns the provided source into a stream and stores it.
|
||||
*
|
||||
* If a string is provided, it is assumed to be a filename, otherwise, it
|
||||
* passes the value directly to `Psr7\stream_for()`.
|
||||
*
|
||||
* @param mixed $source
|
||||
*
|
||||
* @return Stream
|
||||
*/
|
||||
private function determineSource($source)
|
||||
{
|
||||
// Use the contents of a file as the data source.
|
||||
if (is_string($source)) {
|
||||
$source = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\try_fopen($source, 'r');
|
||||
}
|
||||
// Create a source stream.
|
||||
$stream = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($source);
|
||||
if (!$stream->isReadable()) {
|
||||
throw new \InvalidArgumentException('Source stream must be readable.');
|
||||
}
|
||||
return $stream;
|
||||
}
|
||||
protected function getNumberOfParts($partSize)
|
||||
{
|
||||
if ($sourceSize = $this->source->getSize()) {
|
||||
return ceil($sourceSize / $partSize);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
130
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/UploadState.php
vendored
Normal file
130
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Multipart/UploadState.php
vendored
Normal file
@ -0,0 +1,130 @@
|
||||
<?php
|
||||
|
||||
namespace UglyRobot\Infinite_Uploads\Aws\Multipart;
|
||||
|
||||
/**
|
||||
* Representation of the multipart upload.
|
||||
*
|
||||
* This object keeps track of the state of the upload, including the status and
|
||||
* which parts have been uploaded.
|
||||
*/
|
||||
class UploadState
|
||||
{
|
||||
const CREATED = 0;
|
||||
const INITIATED = 1;
|
||||
const COMPLETED = 2;
|
||||
/** @var array Params used to identity the upload. */
|
||||
private $id;
|
||||
/** @var int Part size being used by the upload. */
|
||||
private $partSize;
|
||||
/** @var array Parts that have been uploaded. */
|
||||
private $uploadedParts = [];
|
||||
/** @var int Identifies the status the upload. */
|
||||
private $status = self::CREATED;
|
||||
/**
|
||||
* @param array $id Params used to identity the upload.
|
||||
*/
|
||||
public function __construct(array $id)
|
||||
{
|
||||
$this->id = $id;
|
||||
}
|
||||
/**
|
||||
* Get the upload's ID, which is a tuple of parameters that can uniquely
|
||||
* identify the upload.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getId()
|
||||
{
|
||||
return $this->id;
|
||||
}
|
||||
/**
|
||||
* Set's the "upload_id", or 3rd part of the upload's ID. This typically
|
||||
* only needs to be done after initiating an upload.
|
||||
*
|
||||
* @param string $key The param key of the upload_id.
|
||||
* @param string $value The param value of the upload_id.
|
||||
*/
|
||||
public function setUploadId($key, $value)
|
||||
{
|
||||
$this->id[$key] = $value;
|
||||
}
|
||||
/**
|
||||
* Get the part size.
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getPartSize()
|
||||
{
|
||||
return $this->partSize;
|
||||
}
|
||||
/**
|
||||
* Set the part size.
|
||||
*
|
||||
* @param $partSize int Size of upload parts.
|
||||
*/
|
||||
public function setPartSize($partSize)
|
||||
{
|
||||
$this->partSize = $partSize;
|
||||
}
|
||||
/**
|
||||
* Marks a part as being uploaded.
|
||||
*
|
||||
* @param int $partNumber The part number.
|
||||
* @param array $partData Data from the upload operation that needs to be
|
||||
* recalled during the complete operation.
|
||||
*/
|
||||
public function markPartAsUploaded($partNumber, array $partData = [])
|
||||
{
|
||||
$this->uploadedParts[$partNumber] = $partData;
|
||||
}
|
||||
/**
|
||||
* Returns whether a part has been uploaded.
|
||||
*
|
||||
* @param int $partNumber The part number.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function hasPartBeenUploaded($partNumber)
|
||||
{
|
||||
return isset($this->uploadedParts[$partNumber]);
|
||||
}
|
||||
/**
|
||||
* Returns a sorted list of all the uploaded parts.
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getUploadedParts()
|
||||
{
|
||||
ksort($this->uploadedParts);
|
||||
return $this->uploadedParts;
|
||||
}
|
||||
/**
|
||||
* Set the status of the upload.
|
||||
*
|
||||
* @param int $status Status is an integer code defined by the constants
|
||||
* CREATED, INITIATED, and COMPLETED on this class.
|
||||
*/
|
||||
public function setStatus($status)
|
||||
{
|
||||
$this->status = $status;
|
||||
}
|
||||
/**
|
||||
* Determines whether the upload state is in the INITIATED status.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isInitiated()
|
||||
{
|
||||
return $this->status === self::INITIATED;
|
||||
}
|
||||
/**
|
||||
* Determines whether the upload state is in the COMPLETED status.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isCompleted()
|
||||
{
|
||||
return $this->status === self::COMPLETED;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user