/home/mip/public_html/img/credit/datatables/Multipart.tar
FormDataPart.php 0000644 00000006123 15152066103 0007602 0 ustar 00 <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part\Multipart;
use Symfony\Component\Mime\Exception\InvalidArgumentException;
use Symfony\Component\Mime\Part\AbstractMultipartPart;
use Symfony\Component\Mime\Part\DataPart;
use Symfony\Component\Mime\Part\TextPart;
/**
* Implements RFC 7578.
*
* @author Fabien Potencier <fabien@symfony.com>
*/
final class FormDataPart extends AbstractMultipartPart
{
private array $fields = [];
/**
* @param array<string|array|DataPart> $fields
*/
public function __construct(array $fields = [])
{
parent::__construct();
$this->fields = $fields;
// HTTP does not support \r\n in header values
$this->getHeaders()->setMaxLineLength(\PHP_INT_MAX);
}
public function getMediaSubtype(): string
{
return 'form-data';
}
public function getParts(): array
{
return $this->prepareFields($this->fields);
}
private function prepareFields(array $fields): array
{
$values = [];
$prepare = function ($item, $key, $root = null) use (&$values, &$prepare) {
if (null === $root && \is_int($key) && \is_array($item)) {
if (1 !== \count($item)) {
throw new InvalidArgumentException(sprintf('Form field values with integer keys can only have one array element, the key being the field name and the value being the field value, %d provided.', \count($item)));
}
$key = key($item);
$item = $item[$key];
}
$fieldName = null !== $root ? sprintf('%s[%s]', $root, $key) : $key;
if (\is_array($item)) {
array_walk($item, $prepare, $fieldName);
return;
}
if (!\is_string($item) && !$item instanceof TextPart) {
throw new InvalidArgumentException(sprintf('The value of the form field "%s" can only be a string, an array, or an instance of TextPart, "%s" given.', $fieldName, get_debug_type($item)));
}
$values[] = $this->preparePart($fieldName, $item);
};
array_walk($fields, $prepare);
return $values;
}
private function preparePart(string $name, string|TextPart $value): TextPart
{
if (\is_string($value)) {
return $this->configurePart($name, new TextPart($value, 'utf-8', 'plain', '8bit'));
}
return $this->configurePart($name, $value);
}
private function configurePart(string $name, TextPart $part): TextPart
{
static $r;
$r ??= new \ReflectionProperty(TextPart::class, 'encoding');
$part->setDisposition('form-data');
$part->setName($name);
// HTTP does not support \r\n in header values
$part->getHeaders()->setMaxLineLength(\PHP_INT_MAX);
$r->setValue($part, '8bit');
return $part;
}
}
AlternativePart.php 0000644 00000001047 15152066103 0010363 0 ustar 00 <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part\Multipart;
use Symfony\Component\Mime\Part\AbstractMultipartPart;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
final class AlternativePart extends AbstractMultipartPart
{
public function getMediaSubtype(): string
{
return 'alternative';
}
}
DigestPart.php 0000644 00000001266 15152066103 0007327 0 ustar 00 <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part\Multipart;
use Symfony\Component\Mime\Part\AbstractMultipartPart;
use Symfony\Component\Mime\Part\MessagePart;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
final class DigestPart extends AbstractMultipartPart
{
public function __construct(MessagePart ...$parts)
{
parent::__construct(...$parts);
}
public function getMediaSubtype(): string
{
return 'digest';
}
}
MixedPart.php 0000644 00000001033 15152066103 0007146 0 ustar 00 <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part\Multipart;
use Symfony\Component\Mime\Part\AbstractMultipartPart;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
final class MixedPart extends AbstractMultipartPart
{
public function getMediaSubtype(): string
{
return 'mixed';
}
}
RelatedPart.php 0000644 00000002570 15152066103 0007467 0 ustar 00 <?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part\Multipart;
use Symfony\Component\Mime\Part\AbstractMultipartPart;
use Symfony\Component\Mime\Part\AbstractPart;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
final class RelatedPart extends AbstractMultipartPart
{
private AbstractPart $mainPart;
public function __construct(AbstractPart $mainPart, AbstractPart $part, AbstractPart ...$parts)
{
$this->mainPart = $mainPart;
$this->prepareParts($part, ...$parts);
parent::__construct($part, ...$parts);
}
public function getParts(): array
{
return array_merge([$this->mainPart], parent::getParts());
}
public function getMediaSubtype(): string
{
return 'related';
}
private function generateContentId(): string
{
return bin2hex(random_bytes(16)).'@symfony';
}
private function prepareParts(AbstractPart ...$parts): void
{
foreach ($parts as $part) {
if (!$part->getHeaders()->has('Content-ID')) {
$part->getHeaders()->setHeaderBody('Id', 'Content-ID', $this->generateContentId());
}
}
}
}
AbstractUploader.php 0000644 00000011201 15152066130 0010506 0 ustar 00 <?php
namespace Aws\Multipart;
use Aws\AwsClientInterface as Client;
use Aws\Exception\AwsException;
use GuzzleHttp\Psr7;
use InvalidArgumentException as IAE;
use Psr\Http\Message\StreamInterface as Stream;
abstract class AbstractUploader extends AbstractUploadManager
{
/** @var Stream Source of the data to be uploaded. */
protected $source;
/**
* @param Client $client
* @param mixed $source
* @param array $config
*/
public function __construct(Client $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(Stream $stream)
{
// Limit what is read from the stream to the part size.
return new 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 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
*/
abstract protected 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\Utils::streamFor()`.
*
* @param mixed $source
*
* @return Stream
*/
private function determineSource($source)
{
// Use the contents of a file as the data source.
if (is_string($source)) {
$source = Psr7\Utils::tryFopen($source, 'r');
}
// Create a source stream.
$stream = Psr7\Utils::streamFor($source);
if (!$stream->isReadable()) {
throw new IAE('Source stream must be readable.');
}
return $stream;
}
protected function getNumberOfParts($partSize)
{
if ($sourceSize = $this->source->getSize()) {
return ceil($sourceSize/$partSize);
}
return null;
}
}
AbstractUploadManager.php 0000644 00000024307 15152066130 0011465 0 ustar 00 <?php
namespace Aws\Multipart;
use Aws\AwsClientInterface as Client;
use Aws\CommandInterface;
use Aws\CommandPool;
use Aws\Exception\AwsException;
use Aws\Exception\MultipartUploadException;
use Aws\Result;
use Aws\ResultInterface;
use GuzzleHttp\Promise;
use GuzzleHttp\Promise\PromiseInterface;
use InvalidArgumentException as IAE;
use Psr\Http\Message\RequestInterface;
/**
* Encapsulates the execution of a multipart upload to S3 or Glacier.
*
* @internal
*/
abstract class AbstractUploadManager implements 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' => MultipartUploadException::class,
];
/** @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(Client $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(): PromiseInterface
{
if ($this->promise) {
return $this->promise;
}
return $this->promise = Promise\Coroutine::of(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(UploadState::INITIATED);
}
// Create a command pool from a generator that yields UploadPart
// commands for each upload part.
$resultHandler = $this->getResultHandler($errors);
$commands = new 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(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
*/
abstract protected 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
*/
abstract protected 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
*/
abstract protected function handleResult(
CommandInterface $command,
ResultInterface $result
);
/**
* Gets the service-specific parameters used to initiate the upload.
*
* @return array
*/
abstract protected function getInitiateParams();
/**
* Gets the service-specific parameters used to complete the upload.
*
* @return array
*/
abstract protected function getCompleteParams();
/**
* Based on the config and service-specific workflow info, creates a
* `Promise` for an `UploadState` object.
*/
private function determineState(): UploadState
{
// 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 IAE('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 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 (
CommandInterface $command,
RequestInterface $request = null
) use ($handler, &$errors) {
return $handler($command, $request)->then(
function (ResultInterface $result) use ($command) {
$this->handleResult($command, $result);
return $result;
},
function (AwsException $e) use (&$errors) {
$errors[$e->getCommand()[$this->info['part_num']]] = $e;
return new 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
*/
abstract protected function getUploadCommands(callable $resultHandler);
}
UploadState.php 0000644 00000006407 15152066130 0007510 0 ustar 00 <?php
namespace 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;
}
}
