mirror of
https://gh.wpcy.net/https://github.com/pixelabs-wp/whitelabel-plugins-update-server.git
synced 2026-04-18 04:02:15 +08:00
242 lines
8.8 KiB
PHP
242 lines
8.8 KiB
PHP
<?php
|
|
|
|
namespace Aws\S3;
|
|
|
|
use Aws\Arn\ArnParser;
|
|
use Aws\Multipart\AbstractUploadManager;
|
|
use Aws\ResultInterface;
|
|
use GuzzleHttp\Psr7;
|
|
|
|
class MultipartCopy extends AbstractUploadManager
|
|
{
|
|
use MultipartUploadingTrait;
|
|
|
|
/** @var string|array */
|
|
private $source;
|
|
/** @var string */
|
|
private $sourceVersionId;
|
|
/** @var ResultInterface */
|
|
private $sourceMetadata;
|
|
|
|
/**
|
|
* Creates a multipart upload for copying an S3 object.
|
|
*
|
|
* The valid configuration options are as follows:
|
|
*
|
|
* - acl: (string) ACL to set on the object being upload. Objects are
|
|
* private by default.
|
|
* - before_complete: (callable) Callback to invoke before the
|
|
* `CompleteMultipartUpload` operation. The callback should have a
|
|
* function signature like `function (Aws\Command $command) {...}`.
|
|
* - before_initiate: (callable) Callback to invoke before the
|
|
* `CreateMultipartUpload` operation. The callback should have a function
|
|
* signature like `function (Aws\Command $command) {...}`.
|
|
* - before_upload: (callable) Callback to invoke before `UploadPartCopy`
|
|
* operations. The callback should have a function signature like
|
|
* `function (Aws\Command $command) {...}`.
|
|
* - bucket: (string, required) Name of the bucket to which the object is
|
|
* being uploaded.
|
|
* - concurrency: (int, default=int(5)) Maximum number of concurrent
|
|
* `UploadPart` operations allowed during the multipart upload.
|
|
* - key: (string, required) Key to use for the object being uploaded.
|
|
* - params: (array) An array of key/value parameters that will be applied
|
|
* to each of the sub-commands run by the uploader as a base.
|
|
* Auto-calculated options will override these parameters. If you need
|
|
* more granularity over parameters to each sub-command, use the before_*
|
|
* options detailed above to update the commands directly.
|
|
* - part_size: (int, default=int(5242880)) Part size, in bytes, to use when
|
|
* doing a multipart upload. This must between 5 MB and 5 GB, inclusive.
|
|
* - state: (Aws\Multipart\UploadState) An object that represents the state
|
|
* of the multipart upload and that is used to resume a previous upload.
|
|
* When this option is provided, the `bucket`, `key`, and `part_size`
|
|
* options are ignored.
|
|
* - source_metadata: (Aws\ResultInterface) An object that represents the
|
|
* result of executing a HeadObject command on the copy source.
|
|
*
|
|
* @param S3ClientInterface $client Client used for the upload.
|
|
* @param string|array $source Location of the data to be copied (in the
|
|
* form /<bucket>/<key>). If the key contains a '?'
|
|
* character, instead pass an array of source_key,
|
|
* source_bucket, and source_version_id.
|
|
* @param array $config Configuration used to perform the upload.
|
|
*/
|
|
public function __construct(
|
|
S3ClientInterface $client,
|
|
$source,
|
|
array $config = []
|
|
) {
|
|
if (is_array($source)) {
|
|
$this->source = $source;
|
|
} else {
|
|
$this->source = $this->getInputSource($source);
|
|
}
|
|
|
|
parent::__construct(
|
|
$client,
|
|
array_change_key_case($config) + ['source_metadata' => null]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* An alias of the self::upload method.
|
|
*
|
|
* @see self::upload
|
|
*/
|
|
public function copy()
|
|
{
|
|
return $this->upload();
|
|
}
|
|
|
|
protected function loadUploadWorkflowInfo()
|
|
{
|
|
return [
|
|
'command' => [
|
|
'initiate' => 'CreateMultipartUpload',
|
|
'upload' => 'UploadPartCopy',
|
|
'complete' => 'CompleteMultipartUpload',
|
|
],
|
|
'id' => [
|
|
'bucket' => 'Bucket',
|
|
'key' => 'Key',
|
|
'upload_id' => 'UploadId',
|
|
],
|
|
'part_num' => 'PartNumber',
|
|
];
|
|
}
|
|
|
|
protected function getUploadCommands(callable $resultHandler)
|
|
{
|
|
$parts = ceil($this->getSourceSize() / $this->determinePartSize());
|
|
|
|
for ($partNumber = 1; $partNumber <= $parts; $partNumber++) {
|
|
// If we haven't already uploaded this part, yield a new part.
|
|
if (!$this->state->hasPartBeenUploaded($partNumber)) {
|
|
$command = $this->client->getCommand(
|
|
$this->info['command']['upload'],
|
|
$this->createPart($partNumber, $parts) + $this->getState()->getId()
|
|
);
|
|
$command->getHandlerList()->appendSign($resultHandler, 'mup');
|
|
yield $command;
|
|
}
|
|
}
|
|
}
|
|
|
|
private function createPart($partNumber, $partsCount)
|
|
{
|
|
$data = [];
|
|
|
|
// Apply custom params to UploadPartCopy data
|
|
$config = $this->getConfig();
|
|
$params = isset($config['params']) ? $config['params'] : [];
|
|
foreach ($params as $k => $v) {
|
|
$data[$k] = $v;
|
|
}
|
|
// The source parameter here is usually a string, but can be overloaded as an array
|
|
// if the key contains a '?' character to specify where the query parameters start
|
|
if (is_array($this->source)) {
|
|
$key = str_replace('%2F', '/', rawurlencode($this->source['source_key']));
|
|
$bucket = $this->source['source_bucket'];
|
|
} else {
|
|
list($bucket, $key) = explode('/', ltrim($this->source, '/'), 2);
|
|
$key = implode(
|
|
'/',
|
|
array_map(
|
|
'urlencode',
|
|
explode('/', rawurldecode($key))
|
|
)
|
|
);
|
|
}
|
|
|
|
$uri = ArnParser::isArn($bucket) ? '' : '/';
|
|
$uri .= $bucket . '/' . $key;
|
|
$data['CopySource'] = $uri;
|
|
$data['PartNumber'] = $partNumber;
|
|
if (!empty($this->sourceVersionId)) {
|
|
$data['CopySource'] .= "?versionId=" . $this->sourceVersionId;
|
|
}
|
|
|
|
$defaultPartSize = $this->determinePartSize();
|
|
$startByte = $defaultPartSize * ($partNumber - 1);
|
|
$data['ContentLength'] = $partNumber < $partsCount
|
|
? $defaultPartSize
|
|
: $this->getSourceSize() - ($defaultPartSize * ($partsCount - 1));
|
|
$endByte = $startByte + $data['ContentLength'] - 1;
|
|
$data['CopySourceRange'] = "bytes=$startByte-$endByte";
|
|
|
|
return $data;
|
|
}
|
|
|
|
protected function extractETag(ResultInterface $result)
|
|
{
|
|
return $result->search('CopyPartResult.ETag');
|
|
}
|
|
|
|
protected function getSourceMimeType()
|
|
{
|
|
return $this->getSourceMetadata()['ContentType'];
|
|
}
|
|
|
|
protected function getSourceSize()
|
|
{
|
|
return $this->getSourceMetadata()['ContentLength'];
|
|
}
|
|
|
|
private function getSourceMetadata()
|
|
{
|
|
if (empty($this->sourceMetadata)) {
|
|
$this->sourceMetadata = $this->fetchSourceMetadata();
|
|
}
|
|
|
|
return $this->sourceMetadata;
|
|
}
|
|
|
|
private function fetchSourceMetadata()
|
|
{
|
|
if ($this->config['source_metadata'] instanceof ResultInterface) {
|
|
return $this->config['source_metadata'];
|
|
}
|
|
//if the source variable was overloaded with an array, use the inputs for key and bucket
|
|
if (is_array($this->source)) {
|
|
$headParams = [
|
|
'Key' => $this->source['source_key'],
|
|
'Bucket' => $this->source['source_bucket']
|
|
];
|
|
if (isset($this->source['source_version_id'])) {
|
|
$this->sourceVersionId = $this->source['source_version_id'];
|
|
$headParams['VersionId'] = $this->sourceVersionId;
|
|
}
|
|
//otherwise, use the default source parsing behavior
|
|
} else {
|
|
list($bucket, $key) = explode('/', ltrim($this->source, '/'), 2);
|
|
$headParams = [
|
|
'Bucket' => $bucket,
|
|
'Key' => $key,
|
|
];
|
|
if (strpos($key, '?')) {
|
|
list($key, $query) = explode('?', $key, 2);
|
|
$headParams['Key'] = $key;
|
|
$query = Psr7\Query::parse($query, false);
|
|
if (isset($query['versionId'])) {
|
|
$this->sourceVersionId = $query['versionId'];
|
|
$headParams['VersionId'] = $this->sourceVersionId;
|
|
}
|
|
}
|
|
}
|
|
return $this->client->headObject($headParams);
|
|
}
|
|
|
|
/**
|
|
* Get the url decoded input source, starting with a slash if it is not an
|
|
* ARN to standardize the source location syntax.
|
|
*
|
|
* @param string $inputSource The source that was passed to the constructor
|
|
* @return string The source, starting with a slash if it's not an arn
|
|
*/
|
|
private function getInputSource($inputSource)
|
|
{
|
|
$sourceBuilder = ArnParser::isArn($inputSource) ? '' : '/';
|
|
$sourceBuilder .= ltrim(rawurldecode($inputSource), '/');
|
|
return $sourceBuilder;
|
|
}
|
|
|
|
}
|
