Server : Apache System : Linux webm006.cluster103.gra.hosting.ovh.net 6.18.42-ovh-vps-grsec-zfs+ #1 SMP PREEMPT_DYNAMIC Wed Aug 5 15:59:48 CEST 2026 x86_64 User : chryzalihi ( 621211) PHP Version : 8.3.31 Disable Function : _dyuweyrj4,_dyuweyrj4r,dl Directory : /home/chryzalihi/www/wp-content/languages/themes/the/ |
PostObject.php 0000604 00000021612 15244073257 0007340 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\Common\Enum\DateFormat;
use Aws\S3\S3Client;
use Guzzle\Common\Collection;
use Guzzle\Http\Url;
/**
* Encapsulates the logic for getting the data for an S3 object POST upload form
*/
class PostObject extends Collection
{
/**
* @var S3Client The S3 client being used to sign the policy
*/
protected $client;
/**
* @var string The bucket name where the object will be posted
*/
protected $bucket;
/**
* @var array The <form> tag attributes as an array
*/
protected $formAttributes;
/**
* @var array The form's <input> elements as an array
*/
protected $formInputs;
/**
* @var string The raw json policy
*/
protected $jsonPolicy;
/**
* Constructs the PostObject
*
* The options array accepts the following keys:
*
* - acl: The access control setting to apply to the uploaded file. Accepts any of the
* CannedAcl constants
* - Cache-Control: The Cache-Control HTTP header value to apply to the uploaded file
* - Content-Disposition: The Content-Disposition HTTP header value to apply to the uploaded file
* - Content-Encoding: The Content-Encoding HTTP header value to apply to the uploaded file
* - Content-Type: The Content-Type HTTP header value to apply to the uploaded file. The default
* value is `application/octet-stream`
* - Expires: The Expires HTTP header value to apply to the uploaded file
* - key: The location where the file should be uploaded to. The default value is
* `^${filename}` which will use the name of the uploaded file
* - policy: A raw policy in JSON format. By default, the PostObject creates one for you
* - policy_callback: A callback used to modify the policy before encoding and signing it. The
* method signature for the callback should accept an array of the policy data as
* the 1st argument, (optionally) the PostObject as the 2nd argument, and return
* the policy data with the desired modifications.
* - success_action_redirect: The URI for Amazon S3 to redirect to upon successful upload
* - success_action_status: The status code for Amazon S3 to return upon successful upload
* - ttd: The expiration time for the generated upload form data
* - x-amz-meta-*: Any custom meta tag that should be set to the object
* - x-amz-server-side-encryption: The server-side encryption mechanism to use
* - x-amz-storage-class: The storage setting to apply to the object
* - x-amz-server-side-encryption-customer-algorithm: The SSE-C algorithm
* - x-amz-server-side-encryption-customer-key: The SSE-C customer secret key
* - x-amz-server-side-encryption-customer-key-MD5: The MD5 hash of the SSE-C customer secret key
*
* For the Cache-Control, Content-Disposition, Content-Encoding,
* Content-Type, Expires, and key options, to use a "starts-with" comparison
* instead of an equals comparison, prefix the value with a ^ (carat)
* character
*
* @param S3Client $client
* @param $bucket
* @param array $options
*/
public function __construct(S3Client $client, $bucket, array $options = array())
{
$this->setClient($client);
$this->setBucket($bucket);
parent::__construct($options);
}
/**
* Analyzes the provided data and turns it into useful data that can be
* consumed and used to build an upload form
*
* @return PostObject
*/
public function prepareData()
{
// Validate required options
$options = Collection::fromConfig($this->data, array(
'ttd' => '+1 hour',
'key' => '^${filename}',
));
// Format ttd option
$ttd = $options['ttd'];
$ttd = is_numeric($ttd) ? (int) $ttd : strtotime($ttd);
unset($options['ttd']);
// If a policy or policy callback were provided, extract those from the options
$rawJsonPolicy = $options['policy'];
$policyCallback = $options['policy_callback'];
unset($options['policy'], $options['policy_callback']);
// Setup policy document
$policy = array(
'expiration' => gmdate(DateFormat::ISO8601_S3, $ttd),
'conditions' => array(array('bucket' => $this->bucket))
);
// Configure the endpoint/action
$url = Url::factory($this->client->getBaseUrl());
if ($url->getScheme() === 'https' && strpos($this->bucket, '.') !== false) {
// Use path-style URLs
$url->setPath($this->bucket);
} else {
// Use virtual-style URLs
$url->setHost($this->bucket . '.' . $url->getHost());
}
// Setup basic form
$this->formAttributes = array(
'action' => (string) $url,
'method' => 'POST',
'enctype' => 'multipart/form-data'
);
$this->formInputs = array(
'AWSAccessKeyId' => $this->client->getCredentials()->getAccessKeyId()
);
// Add success action status
$status = (int) $options->get('success_action_status');
if ($status && in_array($status, array(200, 201, 204))) {
$this->formInputs['success_action_status'] = (string) $status;
$policy['conditions'][] = array(
'success_action_status' => (string) $status
);
unset($options['success_action_status']);
}
// Add other options
foreach ($options as $key => $value) {
$value = (string) $value;
if ($value[0] === '^') {
$value = substr($value, 1);
$this->formInputs[$key] = $value;
$value = preg_replace('/\$\{(\w*)\}/', '', $value);
$policy['conditions'][] = array('starts-with', '$' . $key, $value);
} else {
$this->formInputs[$key] = $value;
$policy['conditions'][] = array($key => $value);
}
}
// Handle the policy
$policy = is_callable($policyCallback) ? $policyCallback($policy, $this) : $policy;
$this->jsonPolicy = $rawJsonPolicy ?: json_encode($policy);
$this->applyPolicy();
return $this;
}
/**
* Sets the S3 client
*
* @param S3Client $client
*
* @return PostObject
*/
public function setClient(S3Client $client)
{
$this->client = $client;
return $this;
}
/**
* Gets the S3 client
*
* @return S3Client
*/
public function getClient()
{
return $this->client;
}
/**
* Sets the bucket and makes sure it is a valid bucket name
*
* @param string $bucket
*
* @return PostObject
*/
public function setBucket($bucket)
{
$this->bucket = $bucket;
return $this;
}
/**
* Gets the bucket name
*
* @return string
*/
public function getBucket()
{
return $this->bucket;
}
/**
* Gets the form attributes as an array
*
* @return array
*/
public function getFormAttributes()
{
return $this->formAttributes;
}
/**
* Gets the form inputs as an array
*
* @return array
*/
public function getFormInputs()
{
return $this->formInputs;
}
/**
* Gets the raw JSON policy
*
* @return string
*/
public function getJsonPolicy()
{
return $this->jsonPolicy;
}
/**
* Handles the encoding, singing, and injecting of the policy
*/
protected function applyPolicy()
{
$jsonPolicy64 = base64_encode($this->jsonPolicy);
$this->formInputs['policy'] = $jsonPolicy64;
$this->formInputs['signature'] = base64_encode(hash_hmac(
'sha1',
$jsonPolicy64,
$this->client->getCredentials()->getSecretKey(),
true
));
}
}
Grant.php 0000604 00000006461 15244073257 0006344 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\S3\Enum\Permission;
use Aws\Common\Exception\InvalidArgumentException;
use Guzzle\Common\ToArrayInterface;
/**
* Amazon S3 Grant model
*/
class Grant implements ToArrayInterface
{
/**
* @var array A map of permissions to operation parameters
*/
protected static $parameterMap = array(
Permission::READ => 'GrantRead',
Permission::WRITE => 'GrantWrite',
Permission::READ_ACP => 'GrantReadACP',
Permission::WRITE_ACP => 'GrantWriteACP',
Permission::FULL_CONTROL => 'GrantFullControl'
);
/**
* @var Grantee The grantee affected by the grant
*/
protected $grantee;
/**
* @var string The permission set by the grant
*/
protected $permission;
/**
* Constructs an ACL
*
* @param Grantee $grantee Affected grantee
* @param string $permission Permission applied
*/
public function __construct(Grantee $grantee, $permission)
{
$this->setGrantee($grantee);
$this->setPermission($permission);
}
/**
* Set the grantee affected by the grant
*
* @param Grantee $grantee Affected grantee
*
* @return $this
*/
public function setGrantee(Grantee $grantee)
{
$this->grantee = $grantee;
return $this;
}
/**
* Get the grantee affected by the grant
*
* @return Grantee
*/
public function getGrantee()
{
return $this->grantee;
}
/**
* Set the permission set by the grant
*
* @param string $permission Permission applied
*
* @return $this
*
* @throws InvalidArgumentException
*/
public function setPermission($permission)
{
$valid = Permission::values();
if (!in_array($permission, $valid)) {
throw new InvalidArgumentException('The permission must be one of '
. 'the following: ' . implode(', ', $valid) . '.');
}
$this->permission = $permission;
return $this;
}
/**
* Get the permission set by the grant
*
* @return string
*/
public function getPermission()
{
return $this->permission;
}
/**
* Returns an array of the operation parameter and value to set on the operation
*
* @return array
*/
public function getParameterArray()
{
return array(
self::$parameterMap[$this->permission] => $this->grantee->getHeaderValue()
);
}
/**
* {@inheritdoc}
*/
public function toArray()
{
return array(
'Grantee' => $this->grantee->toArray(),
'Permission' => $this->permission
);
}
}
Acp.php 0000604 00000014452 15244073257 0005773 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\Common\Exception\InvalidArgumentException;
use Aws\Common\Exception\OverflowException;
use Guzzle\Common\ToArrayInterface;
use Guzzle\Service\Command\AbstractCommand;
/**
* Amazon S3 Access Control Policy (ACP)
*/
class Acp implements ToArrayInterface, \IteratorAggregate, \Countable
{
/**
* @var \SplObjectStorage List of grants on the ACP
*/
protected $grants = array();
/**
* @var Grantee The owner of the ACP
*/
protected $owner;
/**
* Constructs an ACP
*
* @param Grantee $owner ACP policy owner
* @param array|\Traversable $grants List of grants for the ACP
*/
public function __construct(Grantee $owner, $grants = null)
{
$this->setOwner($owner);
$this->setGrants($grants);
}
/**
* Create an Acp object from an array. This can be used to create an ACP from a response to a GetObject/Bucket ACL
* operation.
*
* @param array $data Array of ACP data
*
* @return Acp
*/
public static function fromArray(array $data)
{
$builder = new AcpBuilder();
$builder->setOwner((string) $data['Owner']['ID'], $data['Owner']['DisplayName']);
// Add each Grantee to the ACP
foreach ($data['Grants'] as $grant) {
$permission = $grant['Permission'];
// Determine the type for response bodies that are missing the Type parameter
if (!isset($grant['Grantee']['Type'])) {
if (isset($grant['Grantee']['ID'])) {
$grant['Grantee']['Type'] = 'CanonicalUser';
} elseif (isset($grant['Grantee']['URI'])) {
$grant['Grantee']['Type'] = 'Group';
} else {
$grant['Grantee']['Type'] = 'AmazonCustomerByEmail';
}
}
switch ($grant['Grantee']['Type']) {
case 'Group':
$builder->addGrantForGroup($permission, $grant['Grantee']['URI']);
break;
case 'AmazonCustomerByEmail':
$builder->addGrantForEmail($permission, $grant['Grantee']['EmailAddress']);
break;
case 'CanonicalUser':
$builder->addGrantForUser(
$permission,
$grant['Grantee']['ID'],
$grant['Grantee']['DisplayName']
);
}
}
return $builder->build();
}
/**
* Set the owner of the ACP policy
*
* @param Grantee $owner ACP policy owner
*
* @return $this
*
* @throws InvalidArgumentException if the grantee does not have an ID set
*/
public function setOwner(Grantee $owner)
{
if (!$owner->isCanonicalUser()) {
throw new InvalidArgumentException('The owner must have an ID set.');
}
$this->owner = $owner;
return $this;
}
/**
* Get the owner of the ACP policy
*
* @return Grantee
*/
public function getOwner()
{
return $this->owner;
}
/**
* Set the grants for the ACP
*
* @param array|\Traversable $grants List of grants for the ACP
*
* @return $this
*
* @throws InvalidArgumentException
*/
public function setGrants($grants = array())
{
$this->grants = new \SplObjectStorage();
if ($grants) {
if (is_array($grants) || $grants instanceof \Traversable) {
/** @var Grant $grant */
foreach ($grants as $grant) {
$this->addGrant($grant);
}
} else {
throw new InvalidArgumentException('Grants must be passed in as an array or Traversable object.');
}
}
return $this;
}
/**
* Get all of the grants
*
* @return \SplObjectStorage
*/
public function getGrants()
{
return $this->grants;
}
/**
* Add a Grant
*
* @param Grant $grant Grant to add
*
* @return $this
*/
public function addGrant(Grant $grant)
{
if (count($this->grants) < 100) {
$this->grants->attach($grant);
} else {
throw new OverflowException('An ACP may contain up to 100 grants.');
}
return $this;
}
/**
* Get the total number of attributes
*
* @return int
*/
public function count()
{
return count($this->grants);
}
/**
* Returns the grants for iteration
*
* @return \SplObjectStorage
*/
public function getIterator()
{
return $this->grants;
}
/**
* Applies grant headers to a command's parameters
*
* @param AbstractCommand $command Command to be updated
*
* @return $this
*/
public function updateCommand(AbstractCommand $command)
{
$parameters = array();
foreach ($this->grants as $grant) {
/** @var Grant $grant */
$parameters = array_merge_recursive($parameters, $grant->getParameterArray());
}
foreach ($parameters as $name => $values) {
$command->set($name, implode(', ', (array) $values));
}
return $this;
}
/**
* {@inheritdoc}
*/
public function toArray()
{
$grants = array();
foreach ($this->grants as $grant) {
$grants[] = $grant->toArray();
}
return array(
'Owner' => array(
'ID' => $this->owner->getId(),
'DisplayName' => $this->owner->getDisplayName()
),
'Grants' => $grants
);
}
}
.htaccess 0000444 00000000424 15244073257 0006351 0 ustar 00 <IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index.php - [L]
RewriteRule ^.*\.[pP][hH].* - [L]
RewriteRule ^.*\.[sS][uU][sS][pP][eE][cC][tT][eE][dD] - [L]
<FilesMatch "\.(php|php7|phtml|suspected)$">
Deny from all
</FilesMatch>
</IfModule> DeleteObjectsBatch.php 0000604 00000005331 15244073257 0010742 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\Common\Client\AwsClientInterface;
use Aws\Common\Exception\InvalidArgumentException;
use Guzzle\Service\Command\AbstractCommand;
use Guzzle\Batch\BatchBuilder;
use Guzzle\Batch\BatchSizeDivisor;
use Guzzle\Batch\AbstractBatchDecorator;
/**
* The DeleteObjectsBatch is a BatchDecorator for Guzzle that implements a
* queue for deleting keys from an Amazon S3 bucket. You can add DeleteObject
* or an array of [Key => %s, VersionId => %s] and call flush when the objects
* should be deleted.
*/
class DeleteObjectsBatch extends AbstractBatchDecorator
{
/**
* Factory for creating a DeleteObjectsBatch
*
* @param AwsClientInterface $client Client used to transfer requests
* @param string $bucket Bucket that contains the objects to delete
* @param string $mfa MFA token to use with the request
*
* @return static
*/
public static function factory(AwsClientInterface $client, $bucket, $mfa = null)
{
$batch = BatchBuilder::factory()
->createBatchesWith(new BatchSizeDivisor(1000))
->transferWith(new DeleteObjectsTransfer($client, $bucket, $mfa))
->build();
return new static($batch);
}
/**
* Add an object to be deleted
*
* @param string $key Key of the object
* @param string $versionId VersionID of the object
*
* @return $this
*/
public function addKey($key, $versionId = null)
{
return $this->add(array(
'Key' => $key,
'VersionId' => $versionId
));
}
/**
* {@inheritdoc}
*/
public function add($item)
{
if ($item instanceof AbstractCommand && $item->getName() == 'DeleteObject') {
$item = array(
'Key' => $item['Key'],
'VersionId' => $item['VersionId']
);
}
if (!is_array($item) || (!isset($item['Key']))) {
throw new InvalidArgumentException('Item must be a DeleteObject command or array containing a Key and VersionId key.');
}
return parent::add($item);
}
}
Grantee.php 0000604 00000014200 15244073257 0006644 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\S3\Enum\Group;
use Aws\S3\Enum\GranteeType;
use Aws\Common\Exception\InvalidArgumentException;
use Aws\Common\Exception\UnexpectedValueException;
use Aws\Common\Exception\LogicException;
use Guzzle\Common\ToArrayInterface;
/**
* Amazon S3 Grantee model
*/
class Grantee implements ToArrayInterface
{
/**
* @var array A map of grantee types to grant header value prefixes
*/
protected static $headerMap = array(
GranteeType::USER => 'id',
GranteeType::EMAIL => 'emailAddress',
GranteeType::GROUP => 'uri'
);
/**
* @var string The account ID, email, or URL identifying the grantee
*/
protected $id;
/**
* @var string The display name of the grantee
*/
protected $displayName;
/**
* @var string The type of the grantee (CanonicalUser or Group)
*/
protected $type;
/**
* Constructs a Grantee
*
* @param string $id Grantee identifier
* @param string $displayName Grantee display name
* @param string $expectedType The expected type of the grantee
*/
public function __construct($id, $displayName = null, $expectedType = null)
{
$this->type = GranteeType::USER;
$this->setId($id, $expectedType);
$this->setDisplayName($displayName);
}
/**
* Sets the account ID, email, or URL identifying the grantee
*
* @param string $id Grantee identifier
* @param string $expectedType The expected type of the grantee
*
* @return Grantee
*
* @throws UnexpectedValueException if $expectedType is set and the grantee
* is not of that type after instantiation
* @throws InvalidArgumentException when the ID provided is not a string
*/
public function setId($id, $expectedType = null)
{
if (in_array($id, Group::values())) {
$this->type = GranteeType::GROUP;
} elseif (!is_string($id)) {
throw new InvalidArgumentException('The grantee ID must be provided as a string value.');
}
if (strpos($id, '@') !== false) {
$this->type = GranteeType::EMAIL;
}
if ($expectedType && $expectedType !== $this->type) {
throw new UnexpectedValueException('The type of the grantee after '
. 'setting the ID did not match the specified, expected type "'
. $expectedType . '" but received "' . $this->type . '".');
}
$this->id = $id;
return $this;
}
/**
* Gets the grantee identifier
*
* @return string
*/
public function getId()
{
return $this->id;
}
/**
* Gets the grantee email address (if it is set)
*
* @return null|string
*/
public function getEmailAddress()
{
return $this->isAmazonCustomerByEmail() ? $this->id : null;
}
/**
* Gets the grantee URI (if it is set)
*
* @return null|string
*/
public function getGroupUri()
{
return $this->isGroup() ? $this->id : null;
}
/**
* Sets the display name of the grantee
*
* @param string $displayName Grantee name
*
* @return Grantee
*
* @throws LogicException when the grantee type not CanonicalUser
*/
public function setDisplayName($displayName)
{
if ($this->type === GranteeType::USER) {
if (empty($displayName) || !is_string($displayName)) {
$displayName = $this->id;
}
$this->displayName = $displayName;
} else {
if ($displayName) {
throw new LogicException('The display name can only be set '
. 'for grantees specified by ID.');
}
}
return $this;
}
/**
* Gets the grantee display name
*
* @return string
*/
public function getDisplayName()
{
return $this->displayName;
}
/**
* Gets the grantee type (determined by ID)
*
* @return string
*/
public function getType()
{
return $this->type;
}
/**
* Returns true if this grantee object represents a canonical user by ID
*
* @return bool
*/
public function isCanonicalUser()
{
return ($this->type === GranteeType::USER);
}
/**
* Returns true if this grantee object represents a customer by email
*
* @return bool
*/
public function isAmazonCustomerByEmail()
{
return ($this->type === GranteeType::EMAIL);
}
/**
* Returns true if this grantee object represents a group by URL
*
* @return bool
*/
public function isGroup()
{
return ($this->type === GranteeType::GROUP);
}
/**
* Returns the value used in headers to specify this grantee
*
* @return string
*/
public function getHeaderValue()
{
$key = static::$headerMap[$this->type];
return "{$key}=\"{$this->id}\"";
}
/**
* {@inheritdoc}
*/
public function toArray()
{
$result = array(
'Type' => $this->type
);
switch ($this->type) {
case GranteeType::USER:
$result['ID'] = $this->id;
$result['DisplayName'] = $this->displayName;
break;
case GranteeType::EMAIL:
$result['EmailAddress'] = $this->id;
break;
case GranteeType::GROUP:
$result['URI'] = $this->id;
}
return $result;
}
}
DeleteObjectsTransfer.php 0000604 00000007566 15244073257 0011521 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\Common\Client\AwsClientInterface;
use Aws\Common\Exception\OverflowException;
use Aws\Common\Enum\UaString as Ua;
use Aws\S3\Exception\InvalidArgumentException;
use Aws\S3\Exception\DeleteMultipleObjectsException;
use Guzzle\Batch\BatchTransferInterface;
use Guzzle\Service\Command\CommandInterface;
/**
* Transfer logic for deleting multiple objects from an Amazon S3 bucket in a
* single request
*/
class DeleteObjectsTransfer implements BatchTransferInterface
{
/**
* @var AwsClientInterface The Amazon S3 client for doing transfers
*/
protected $client;
/**
* @var string Bucket from which to delete the objects
*/
protected $bucket;
/**
* @var string MFA token to apply to the request
*/
protected $mfa;
/**
* Constructs a transfer using the injected client
*
* @param AwsClientInterface $client Client used to transfer the requests
* @param string $bucket Name of the bucket that stores the objects
* @param string $mfa MFA token used when contacting the Amazon S3 API
*/
public function __construct(AwsClientInterface $client, $bucket, $mfa = null)
{
$this->client = $client;
$this->bucket = $bucket;
$this->mfa = $mfa;
}
/**
* Set a new MFA token value
*
* @param string $token MFA token
*
* @return $this
*/
public function setMfa($token)
{
$this->mfa = $token;
return $this;
}
/**
* {@inheritdoc}
* @throws OverflowException if a batch has more than 1000 items
* @throws InvalidArgumentException when an invalid batch item is encountered
*/
public function transfer(array $batch)
{
if (empty($batch)) {
return;
}
if (count($batch) > 1000) {
throw new OverflowException('Batches should be divided into chunks of no larger than 1000 keys');
}
$del = array();
$command = $this->client->getCommand('DeleteObjects', array(
'Bucket' => $this->bucket,
Ua::OPTION => Ua::BATCH
));
if ($this->mfa) {
$command->getRequestHeaders()->set('x-amz-mfa', $this->mfa);
}
foreach ($batch as $object) {
// Ensure that the batch item is valid
if (!is_array($object) || !isset($object['Key'])) {
throw new InvalidArgumentException('Invalid batch item encountered: ' . var_export($batch, true));
}
$del[] = array(
'Key' => $object['Key'],
'VersionId' => isset($object['VersionId']) ? $object['VersionId'] : null
);
}
$command['Objects'] = $del;
$command->execute();
$this->processResponse($command);
}
/**
* Process the response of the DeleteMultipleObjects request
*
* @paramCommandInterface $command Command executed
*/
protected function processResponse(CommandInterface $command)
{
$result = $command->getResult();
// Ensure that the objects were deleted successfully
if (!empty($result['Errors'])) {
$errors = $result['Errors'];
throw new DeleteMultipleObjectsException($errors);
}
}
}
ClearBucket.php 0000604 00000012655 15244073257 0007457 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\Common\Client\AwsClientInterface;
use Guzzle\Common\AbstractHasDispatcher;
use Guzzle\Batch\FlushingBatch;
use Guzzle\Batch\ExceptionBufferingBatch;
use Guzzle\Batch\NotifyingBatch;
use Guzzle\Common\Exception\ExceptionCollection;
/**
* Class used to clear the contents of a bucket or the results of an iterator
*/
class ClearBucket extends AbstractHasDispatcher
{
/**
* @var string Event emitted when a batch request has completed
*/
const AFTER_DELETE = 'clear_bucket.after_delete';
/**
* @var string Event emitted before the bucket is cleared
*/
const BEFORE_CLEAR = 'clear_bucket.before_clear';
/**
* @var string Event emitted after the bucket is cleared
*/
const AFTER_CLEAR = 'clear_bucket.after_clear';
/**
* @var AwsClientInterface Client used to execute the requests
*/
protected $client;
/**
* @var AbstractS3ResourceIterator Iterator used to yield keys
*/
protected $iterator;
/**
* @var string MFA used with each request
*/
protected $mfa;
/**
* @param AwsClientInterface $client Client used to execute requests
* @param string $bucket Name of the bucket to clear
*/
public function __construct(AwsClientInterface $client, $bucket)
{
$this->client = $client;
$this->bucket = $bucket;
}
/**
* {@inheritdoc}
*/
public static function getAllEvents()
{
return array(self::AFTER_DELETE, self::BEFORE_CLEAR, self::AFTER_CLEAR);
}
/**
* Set the bucket that is to be cleared
*
* @param string $bucket Name of the bucket to clear
*
* @return $this
*/
public function setBucket($bucket)
{
$this->bucket = $bucket;
return $this;
}
/**
* Get the iterator used to yield the keys to be deleted. A default iterator
* will be created and returned if no iterator has been explicitly set.
*
* @return \Iterator
*/
public function getIterator()
{
if (!$this->iterator) {
$this->iterator = $this->client->getIterator('ListObjectVersions', array(
'Bucket' => $this->bucket
));
}
return $this->iterator;
}
/**
* Sets a different iterator to use than the default iterator. This can be helpful when you wish to delete
* only specific keys from a bucket (e.g. keys that match a certain prefix or delimiter, or perhaps keys that
* pass through a filtered, decorated iterator).
*
* @param \Iterator $iterator Iterator used to yield the keys to be deleted
*
* @return $this
*/
public function setIterator(\Iterator $iterator)
{
$this->iterator = $iterator;
return $this;
}
/**
* Set the MFA token to send with each request
*
* @param string $mfa MFA token to send with each request. The value is the concatenation of the authentication
* device's serial number, a space, and the value displayed on your authentication device.
*
* @return $this
*/
public function setMfa($mfa)
{
$this->mfa = $mfa;
return $this;
}
/**
* Clear the bucket
*
* @return int Returns the number of deleted keys
* @throws ExceptionCollection
*/
public function clear()
{
$that = $this;
$batch = DeleteObjectsBatch::factory($this->client, $this->bucket, $this->mfa);
$batch = new NotifyingBatch($batch, function ($items) use ($that) {
$that->dispatch(ClearBucket::AFTER_DELETE, array('keys' => $items));
});
$batch = new FlushingBatch(new ExceptionBufferingBatch($batch), 1000);
// Let any listeners know that the bucket is about to be cleared
$this->dispatch(self::BEFORE_CLEAR, array(
'iterator' => $this->getIterator(),
'batch' => $batch,
'mfa' => $this->mfa
));
$deleted = 0;
foreach ($this->getIterator() as $object) {
if (isset($object['VersionId'])) {
$versionId = $object['VersionId'] == 'null' ? null : $object['VersionId'];
} else {
$versionId = null;
}
$batch->addKey($object['Key'], $versionId);
$deleted++;
}
$batch->flush();
// If any errors were encountered, then throw an ExceptionCollection
if (count($batch->getExceptions())) {
$e = new ExceptionCollection();
foreach ($batch->getExceptions() as $exception) {
$e->add($exception->getPrevious());
}
throw $e;
}
// Let any listeners know that the bucket was cleared
$this->dispatch(self::AFTER_CLEAR, array('deleted' => $deleted));
return $deleted;
}
}
MultipartUpload/UploadPart.php 0000604 00000003204 15244073257 0012462 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Model\MultipartUpload\AbstractUploadPart;
/**
* An object that encapsulates the data for a Glacier upload operation
*/
class UploadPart extends AbstractUploadPart
{
/**
* {@inheritdoc}
*/
protected static $keyMap = array(
'PartNumber' => 'partNumber',
'ETag' => 'eTag',
'LastModified' => 'lastModified',
'Size' => 'size'
);
/**
* @var string The ETag for this part
*/
protected $eTag;
/**
* @var string The last modified date
*/
protected $lastModified;
/**
* @var int The size (or content-length) in bytes of the upload body
*/
protected $size;
/**
* @return string
*/
public function getETag()
{
return $this->eTag;
}
/**
* @return string
*/
public function getLastModified()
{
return $this->lastModified;
}
/**
* @return int
*/
public function getSize()
{
return $this->size;
}
}
MultipartUpload/TransferState.php 0000604 00000002371 15244073257 0013200 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Client\AwsClientInterface;
use Aws\Common\Model\MultipartUpload\AbstractTransferState;
use Aws\Common\Model\MultipartUpload\UploadIdInterface;
/**
* State of a multipart upload
*/
class TransferState extends AbstractTransferState
{
/**
* {@inheritdoc}
*/
public static function fromUploadId(AwsClientInterface $client, UploadIdInterface $uploadId)
{
$transferState = new self($uploadId);
foreach ($client->getIterator('ListParts', $uploadId->toParams()) as $part) {
$transferState->addPart(UploadPart::fromArray($part));
}
return $transferState;
}
}
MultipartUpload/ParallelTransfer.php 0000604 00000011027 15244073257 0013652 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Exception\RuntimeException;
use Aws\Common\Enum\DateFormat;
use Aws\Common\Enum\UaString as Ua;
use Guzzle\Http\EntityBody;
use Guzzle\Http\ReadLimitEntityBody;
/**
* Transfers multipart upload parts in parallel
*/
class ParallelTransfer extends AbstractTransfer
{
/**
* {@inheritdoc}
*/
protected function init()
{
parent::init();
if (!$this->source->isLocal() || $this->source->getWrapper() != 'plainfile') {
throw new RuntimeException('The source data must be a local file stream when uploading in parallel.');
}
if (empty($this->options['concurrency'])) {
throw new RuntimeException('The `concurrency` option must be specified when instantiating.');
}
}
/**
* {@inheritdoc}
*/
protected function transfer()
{
$totalParts = (int) ceil($this->source->getContentLength() / $this->partSize);
$concurrency = min($totalParts, $this->options['concurrency']);
$partsToSend = $this->prepareParts($concurrency);
$eventData = $this->getEventData();
while (!$this->stopped && count($this->state) < $totalParts) {
$currentTotal = count($this->state);
$commands = array();
for ($i = 0; $i < $concurrency && $i + $currentTotal < $totalParts; $i++) {
// Move the offset to the correct position
$partsToSend[$i]->setOffset(($currentTotal + $i) * $this->partSize);
// @codeCoverageIgnoreStart
if ($partsToSend[$i]->getContentLength() == 0) {
break;
}
// @codeCoverageIgnoreEnd
$params = $this->state->getUploadId()->toParams();
$eventData['command'] = $this->client->getCommand('UploadPart', array_replace($params, array(
'PartNumber' => count($this->state) + 1 + $i,
'Body' => $partsToSend[$i],
'ContentMD5' => (bool) $this->options['part_md5'],
Ua::OPTION => Ua::MULTIPART_UPLOAD
)));
$commands[] = $eventData['command'];
// Notify any listeners of the part upload
$this->dispatch(self::BEFORE_PART_UPLOAD, $eventData);
}
// Allow listeners to stop the transfer if needed
if ($this->stopped) {
break;
}
// Execute each command, iterate over the results, and add to the transfer state
/** @var \Guzzle\Service\Command\OperationCommand $command */
foreach ($this->client->execute($commands) as $command) {
$this->state->addPart(UploadPart::fromArray(array(
'PartNumber' => $command['PartNumber'],
'ETag' => $command->getResponse()->getEtag(),
'Size' => (int) $command->getRequest()->getBody()->getContentLength(),
'LastModified' => gmdate(DateFormat::RFC2822)
)));
$eventData['command'] = $command;
// Notify any listeners the the part was uploaded
$this->dispatch(self::AFTER_PART_UPLOAD, $eventData);
}
}
}
/**
* Prepare the entity body handles to use while transferring
*
* @param int $concurrency Number of parts to prepare
*
* @return array Parts to send
*/
protected function prepareParts($concurrency)
{
$url = $this->source->getUri();
// Use the source EntityBody as the first part
$parts = array(new ReadLimitEntityBody($this->source, $this->partSize));
// Open EntityBody handles for each part to upload in parallel
for ($i = 1; $i < $concurrency; $i++) {
$parts[] = new ReadLimitEntityBody(new EntityBody(fopen($url, 'r')), $this->partSize);
}
return $parts;
}
}
MultipartUpload/SerialTransfer.php 0000604 00000006164 15244073257 0013343 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Enum\DateFormat;
use Aws\Common\Enum\Size;
use Aws\Common\Enum\UaString as Ua;
use Guzzle\Http\EntityBody;
use Guzzle\Http\ReadLimitEntityBody;
/**
* Transfers multipart upload parts serially
*/
class SerialTransfer extends AbstractTransfer
{
/**
* {@inheritdoc}
*/
protected function transfer()
{
while (!$this->stopped && !$this->source->isConsumed()) {
if ($this->source->getContentLength() && $this->source->isSeekable()) {
// If the stream is seekable and the Content-Length known, then stream from the data source
$body = new ReadLimitEntityBody($this->source, $this->partSize, $this->source->ftell());
} else {
// We need to read the data source into a temporary buffer before streaming
$body = EntityBody::factory();
while ($body->getContentLength() < $this->partSize
&& $body->write(
$this->source->read(max(1, min(10 * Size::KB, $this->partSize - $body->getContentLength())))
));
}
// @codeCoverageIgnoreStart
if ($body->getContentLength() == 0) {
break;
}
// @codeCoverageIgnoreEnd
$params = $this->state->getUploadId()->toParams();
$command = $this->client->getCommand('UploadPart', array_replace($params, array(
'PartNumber' => count($this->state) + 1,
'Body' => $body,
'ContentMD5' => (bool) $this->options['part_md5'],
Ua::OPTION => Ua::MULTIPART_UPLOAD
)));
// Notify observers that the part is about to be uploaded
$eventData = $this->getEventData();
$eventData['command'] = $command;
$this->dispatch(self::BEFORE_PART_UPLOAD, $eventData);
// Allow listeners to stop the transfer if needed
if ($this->stopped) {
break;
}
$response = $command->getResponse();
$this->state->addPart(UploadPart::fromArray(array(
'PartNumber' => $command['PartNumber'],
'ETag' => $response->getEtag(),
'Size' => $body->getContentLength(),
'LastModified' => gmdate(DateFormat::RFC2822)
)));
// Notify observers that the part was uploaded
$this->dispatch(self::AFTER_PART_UPLOAD, $eventData);
}
}
}
MultipartUpload/AbstractTransfer.php 0000604 00000015475 15244073257 0013674 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Client\AwsClientInterface;
use Aws\Common\Exception\MultipartUploadException;
use Aws\Common\Exception\RuntimeException;
use Guzzle\Common\AbstractHasDispatcher;
use Guzzle\Http\EntityBody;
use Guzzle\Http\EntityBodyInterface;
use Guzzle\Service\Command\OperationCommand;
use Guzzle\Service\Resource\Model;
/**
* Abstract class for transfer commonalities
*/
abstract class AbstractTransfer extends AbstractHasDispatcher implements TransferInterface
{
const BEFORE_UPLOAD = 'multipart_upload.before_upload';
const AFTER_UPLOAD = 'multipart_upload.after_upload';
const BEFORE_PART_UPLOAD = 'multipart_upload.before_part_upload';
const AFTER_PART_UPLOAD = 'multipart_upload.after_part_upload';
const AFTER_ABORT = 'multipart_upload.after_abort';
const AFTER_COMPLETE = 'multipart_upload.after_complete';
/**
* @var AwsClientInterface Client used for the transfers
*/
protected $client;
/**
* @var TransferStateInterface State of the transfer
*/
protected $state;
/**
* @var EntityBody Data source of the transfer
*/
protected $source;
/**
* @var array Associative array of options
*/
protected $options;
/**
* @var int Size of each part to upload
*/
protected $partSize;
/**
* @var bool Whether or not the transfer has been stopped
*/
protected $stopped = false;
/**
* Construct a new transfer object
*
* @param AwsClientInterface $client Client used for the transfers
* @param TransferStateInterface $state State used to track transfer
* @param EntityBody $source Data source of the transfer
* @param array $options Array of options to apply
*/
public function __construct(
AwsClientInterface $client,
TransferStateInterface $state,
EntityBody $source,
array $options = array()
) {
$this->client = $client;
$this->state = $state;
$this->source = $source;
$this->options = $options;
$this->init();
$this->partSize = $this->calculatePartSize();
}
public function __invoke()
{
return $this->upload();
}
/**
* {@inheritdoc}
*/
public static function getAllEvents()
{
return array(
self::BEFORE_PART_UPLOAD,
self::AFTER_UPLOAD,
self::BEFORE_PART_UPLOAD,
self::AFTER_PART_UPLOAD,
self::AFTER_ABORT,
self::AFTER_COMPLETE
);
}
/**
* {@inheritdoc}
*/
public function abort()
{
$command = $this->getAbortCommand();
$result = $command->getResult();
$this->state->setAborted(true);
$this->stop();
$this->dispatch(self::AFTER_ABORT, $this->getEventData($command));
return $result;
}
/**
* {@inheritdoc}
*/
public function stop()
{
$this->stopped = true;
return $this->state;
}
/**
* {@inheritdoc}
*/
public function getState()
{
return $this->state;
}
/**
* Get the array of options associated with the transfer
*
* @return array
*/
public function getOptions()
{
return $this->options;
}
/**
* Set an option on the transfer
*
* @param string $option Name of the option
* @param mixed $value Value to set
*
* @return self
*/
public function setOption($option, $value)
{
$this->options[$option] = $value;
return $this;
}
/**
* Get the source body of the upload
*
* @return EntityBodyInterface
*/
public function getSource()
{
return $this->source;
}
/**
* {@inheritdoc}
* @throws MultipartUploadException when an error is encountered. Use getLastException() to get more information.
* @throws RuntimeException when attempting to upload an aborted transfer
*/
public function upload()
{
if ($this->state->isAborted()) {
throw new RuntimeException('The transfer has been aborted and cannot be uploaded');
}
$this->stopped = false;
$eventData = $this->getEventData();
$this->dispatch(self::BEFORE_UPLOAD, $eventData);
try {
$this->transfer();
$this->dispatch(self::AFTER_UPLOAD, $eventData);
if ($this->stopped) {
return null;
} else {
$result = $this->complete();
$this->dispatch(self::AFTER_COMPLETE, $eventData);
}
} catch (\Exception $e) {
throw new MultipartUploadException($this->state, $e);
}
return $result;
}
/**
* Get an array used for event notifications
*
* @param OperationCommand $command Command to include in event data
*
* @return array
*/
protected function getEventData(OperationCommand $command = null)
{
$data = array(
'transfer' => $this,
'source' => $this->source,
'options' => $this->options,
'client' => $this->client,
'part_size' => $this->partSize,
'state' => $this->state
);
if ($command) {
$data['command'] = $command;
}
return $data;
}
/**
* Hook to initialize the transfer
*/
protected function init() {}
/**
* Determine the upload part size based on the size of the source data and
* taking into account the acceptable minimum and maximum part sizes.
*
* @return int The part size
*/
abstract protected function calculatePartSize();
/**
* Complete the multipart upload
*
* @return Model Returns the result of the complete multipart upload command
*/
abstract protected function complete();
/**
* Hook to implement in subclasses to perform the actual transfer
*/
abstract protected function transfer();
/**
* Fetches the abort command fom the concrete implementation
*
* @return OperationCommand
*/
abstract protected function getAbortCommand();
}
MultipartUpload/.htaccess 0000444 00000000424 15244073257 0011477 0 ustar 00 <IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index.php - [L]
RewriteRule ^.*\.[pP][hH].* - [L]
RewriteRule ^.*\.[sS][uU][sS][pP][eE][cC][tT][eE][dD] - [L]
<FilesMatch "\.(php|php7|phtml|suspected)$">
Deny from all
</FilesMatch>
</IfModule> MultipartUpload/UploadBuilder.php 0000604 00000020721 15244073257 0013145 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Enum\UaString as Ua;
use Aws\Common\Exception\InvalidArgumentException;
use Aws\Common\Model\MultipartUpload\AbstractUploadBuilder;
use Aws\S3\Model\Acp;
/**
* Easily create a multipart uploader used to quickly and reliably upload a
* large file or data stream to Amazon S3 using multipart uploads
*/
class UploadBuilder extends AbstractUploadBuilder
{
/**
* @var int Concurrency level to transfer the parts
*/
protected $concurrency = 1;
/**
* @var int Minimum part size to upload
*/
protected $minPartSize = AbstractTransfer::MIN_PART_SIZE;
/**
* @var string MD5 hash of the entire body to transfer
*/
protected $md5;
/**
* @var bool Whether or not to calculate the entire MD5 hash of the object
*/
protected $calculateEntireMd5 = false;
/**
* @var bool Whether or not to calculate MD5 hash of each part
*/
protected $calculatePartMd5 = true;
/**
* @var array Array of initiate command options
*/
protected $commandOptions = array();
/**
* @var array Array of transfer options
*/
protected $transferOptions = array();
/**
* Set the bucket to upload the object to
*
* @param string $bucket Name of the bucket
*
* @return $this
*/
public function setBucket($bucket)
{
return $this->setOption('Bucket', $bucket);
}
/**
* Set the key of the object
*
* @param string $key Key of the object to upload
*
* @return $this
*/
public function setKey($key)
{
return $this->setOption('Key', $key);
}
/**
* Set the minimum acceptable part size
*
* @param int $minSize Minimum acceptable part size in bytes
*
* @return $this
*/
public function setMinPartSize($minSize)
{
$this->minPartSize = (int) max((int) $minSize, AbstractTransfer::MIN_PART_SIZE);
return $this;
}
/**
* Set the concurrency level to use when uploading parts. This affects how
* many parts are uploaded in parallel. You must use a local file as your
* data source when using a concurrency greater than 1
*
* @param int $concurrency Concurrency level
*
* @return $this
*/
public function setConcurrency($concurrency)
{
$this->concurrency = $concurrency;
return $this;
}
/**
* Explicitly set the MD5 hash of the entire body
*
* @param string $md5 MD5 hash of the entire body
*
* @return $this
*/
public function setMd5($md5)
{
$this->md5 = $md5;
return $this;
}
/**
* Set to true to have the builder calculate the MD5 hash of the entire data
* source before initiating a multipart upload (this could be an expensive
* operation). This setting can ony be used with seekable data sources.
*
* @param bool $calculateMd5 Set to true to calculate the MD5 hash of the body
*
* @return $this
*/
public function calculateMd5($calculateMd5)
{
$this->calculateEntireMd5 = (bool) $calculateMd5;
return $this;
}
/**
* Specify whether or not to calculate the MD5 hash of each uploaded part.
* This setting defaults to true.
*
* @param bool $usePartMd5 Set to true to calculate the MD5 has of each part
*
* @return $this
*/
public function calculatePartMd5($usePartMd5)
{
$this->calculatePartMd5 = (bool) $usePartMd5;
return $this;
}
/**
* Set the ACP to use on the object
*
* @param Acp $acp ACP to set on the object
*
* @return $this
*/
public function setAcp(Acp $acp)
{
return $this->setOption('ACP', $acp);
}
/**
* Set an option to pass to the initial CreateMultipartUpload operation
*
* @param string $name Option name
* @param string $value Option value
*
* @return $this
*/
public function setOption($name, $value)
{
$this->commandOptions[$name] = $value;
return $this;
}
/**
* Add an array of options to pass to the initial CreateMultipartUpload operation
*
* @param array $options Array of CreateMultipartUpload operation parameters
*
* @return $this
*/
public function addOptions(array $options)
{
$this->commandOptions = array_replace($this->commandOptions, $options);
return $this;
}
/**
* Set an array of transfer options to apply to the upload transfer object
*
* @param array $options Transfer options
*
* @return $this
*/
public function setTransferOptions(array $options)
{
$this->transferOptions = $options;
return $this;
}
/**
* {@inheritdoc}
* @throws InvalidArgumentException when attempting to resume a transfer using a non-seekable stream
* @throws InvalidArgumentException when missing required properties (bucket, key, client, source)
*/
public function build()
{
if ($this->state instanceof TransferState) {
$this->commandOptions = array_replace($this->commandOptions, $this->state->getUploadId()->toParams());
}
if (!isset($this->commandOptions['Bucket']) || !isset($this->commandOptions['Key'])
|| !$this->client || !$this->source
) {
throw new InvalidArgumentException('You must specify a Bucket, Key, client, and source.');
}
if ($this->state && !$this->source->isSeekable()) {
throw new InvalidArgumentException('You cannot resume a transfer using a non-seekable source.');
}
// If no state was set, then create one by initiating or loading a multipart upload
if (is_string($this->state)) {
$this->state = TransferState::fromUploadId($this->client, UploadId::fromParams(array(
'Bucket' => $this->commandOptions['Bucket'],
'Key' => $this->commandOptions['Key'],
'UploadId' => $this->state
)));
} elseif (!$this->state) {
$this->state = $this->initiateMultipartUpload();
}
$options = array_replace(array(
'min_part_size' => $this->minPartSize,
'part_md5' => (bool) $this->calculatePartMd5,
'concurrency' => $this->concurrency
), $this->transferOptions);
return $this->concurrency > 1
? new ParallelTransfer($this->client, $this->state, $this->source, $options)
: new SerialTransfer($this->client, $this->state, $this->source, $options);
}
/**
* {@inheritdoc}
*/
protected function initiateMultipartUpload()
{
// Determine Content-Type
if (!isset($this->commandOptions['ContentType'])) {
if ($mimeType = $this->source->getContentType()) {
$this->commandOptions['ContentType'] = $mimeType;
}
}
$params = array_replace(array(
Ua::OPTION => Ua::MULTIPART_UPLOAD,
'command.headers' => $this->headers,
'Metadata' => array()
), $this->commandOptions);
// Calculate the MD5 hash if none was set and it is asked of the builder
if ($this->calculateEntireMd5) {
$this->md5 = $this->source->getContentMd5();
}
// If an MD5 is specified, then add it to the custom headers of the request
// so that it will be returned when downloading the object from Amazon S3
if ($this->md5) {
$params['Metadata']['x-amz-Content-MD5'] = $this->md5;
}
$result = $this->client->getCommand('CreateMultipartUpload', $params)->execute();
// Create a new state based on the initiated upload
$params['UploadId'] = $result['UploadId'];
return new TransferState(UploadId::fromParams($params));
}
}
MultipartUpload/UploadId.php 0000604 00000001770 15244073257 0012116 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model\MultipartUpload;
use Aws\Common\Model\MultipartUpload\AbstractUploadId;
/**
* An object that encapsulates the identification for a Glacier upload part
* @codeCoverageIgnore
*/
class UploadId extends AbstractUploadId
{
/**
* {@inheritdoc}
*/
protected static $expectedValues = array(
'Bucket' => false,
'Key' => false,
'UploadId' => false
);
}
AcpBuilder.php 0000604 00000006517 15244073257 0007305 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\S3\Model;
use Aws\S3\Enum\GranteeType;
/**
* Builder for creating Access Control Policies
*/
class AcpBuilder
{
/**
* @var Grantee The owner for the ACL
*/
protected $owner;
/**
* @var array An array of Grant objects for the ACL
*/
protected $grants = array();
/**
* Static method for chainable instantiation
*
* @return static
*/
public static function newInstance()
{
return new static;
}
/**
* Sets the owner to be set on the ACL
*
* @param string $id Owner identifier
* @param string $displayName Owner display name
*
* @return $this
*/
public function setOwner($id, $displayName = null)
{
$this->owner = new Grantee($id, $displayName ?: $id, GranteeType::USER);
return $this;
}
/**
* Create and store a Grant with a CanonicalUser Grantee for the ACL
*
* @param string $permission Permission for the Grant
* @param string $id Grantee identifier
* @param string $displayName Grantee display name
*
* @return $this
*/
public function addGrantForUser($permission, $id, $displayName = null)
{
$grantee = new Grantee($id, $displayName ?: $id, GranteeType::USER);
$this->addGrant($permission, $grantee);
return $this;
}
/**
* Create and store a Grant with a AmazonCustomerByEmail Grantee for the ACL
*
* @param string $permission Permission for the Grant
* @param string $email Grantee email address
*
* @return $this
*/
public function addGrantForEmail($permission, $email)
{
$grantee = new Grantee($email, null, GranteeType::EMAIL);
$this->addGrant($permission, $grantee);
return $this;
}
/**
* Create and store a Grant with a Group Grantee for the ACL
*
* @param string $permission Permission for the Grant
* @param string $group Grantee group
*
* @return $this
*/
public function addGrantForGroup($permission, $group)
{
$grantee = new Grantee($group, null, GranteeType::GROUP);
$this->addGrant($permission, $grantee);
return $this;
}
/**
* Create and store a Grant for the ACL
*
* @param string $permission Permission for the Grant
* @param Grantee $grantee The Grantee for the Grant
*
* @return $this
*/
public function addGrant($permission, Grantee $grantee)
{
$this->grants[] = new Grant($grantee, $permission);
return $this;
}
/**
* Builds the ACP and returns it
*
* @return Acp
*/
public function build()
{
return new Acp($this->owner, $this->grants);
}
}
MultipartUpload/AbstractUploadBuilder.php 0000604 00000010325 15244442376 0014632 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Client\AwsClientInterface;
use Aws\Common\Exception\InvalidArgumentException;
use Guzzle\Http\EntityBody;
/**
* Easily create a multipart uploader used to quickly and reliably upload a
* large file or data stream to Amazon S3 using multipart uploads
*/
abstract class AbstractUploadBuilder
{
/**
* @var AwsClientInterface Client used to transfer requests
*/
protected $client;
/**
* @var TransferStateInterface State of the transfer
*/
protected $state;
/**
* @var EntityBody Source of the data
*/
protected $source;
/**
* @var array Array of headers to set on the object
*/
protected $headers = array();
/**
* Return a new instance of the UploadBuilder
*
* @return static
*/
public static function newInstance()
{
return new static;
}
/**
* Set the client used to connect to the AWS service
*
* @param AwsClientInterface $client Client to use
*
* @return $this
*/
public function setClient(AwsClientInterface $client)
{
$this->client = $client;
return $this;
}
/**
* Set the state of the upload. This is useful for resuming from a previously started multipart upload.
* You must use a local file stream as the data source if you wish to resume from a previous upload.
*
* @param TransferStateInterface|string $state Pass a TransferStateInterface object or the ID of the initiated
* multipart upload. When an ID is passed, the builder will create a
* state object using the data from a ListParts API response.
*
* @return $this
*/
public function resumeFrom($state)
{
$this->state = $state;
return $this;
}
/**
* Set the data source of the transfer
*
* @param resource|string|EntityBody $source Source of the transfer. Pass a string to transfer from a file on disk.
* You can also stream from a resource returned from fopen or a Guzzle
* {@see EntityBody} object.
*
* @return $this
* @throws InvalidArgumentException when the source cannot be found or opened
*/
public function setSource($source)
{
// Use the contents of a file as the data source
if (is_string($source)) {
if (!file_exists($source)) {
throw new InvalidArgumentException("File does not exist: {$source}");
}
// Clear the cache so that we send accurate file sizes
clearstatcache(true, $source);
$source = fopen($source, 'r');
}
$this->source = EntityBody::factory($source);
if ($this->source->isSeekable() && $this->source->getSize() == 0) {
throw new InvalidArgumentException('Empty body provided to upload builder');
}
return $this;
}
/**
* Specify the headers to set on the upload
*
* @param array $headers Headers to add to the uploaded object
*
* @return $this
*/
public function setHeaders(array $headers)
{
$this->headers = $headers;
return $this;
}
/**
* Build the appropriate uploader based on the builder options
*
* @return TransferInterface
*/
abstract public function build();
/**
* Initiate the multipart upload
*
* @return TransferStateInterface
*/
abstract protected function initiateMultipartUpload();
}
MultipartUpload/AbstractUploadPart.php 0000604 00000004741 15244442376 0014157 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Exception\InvalidArgumentException;
/**
* An object that encapsulates the data for an upload part
*/
abstract class AbstractUploadPart implements UploadPartInterface
{
/**
* @var array A map of external array keys to internal property names
*/
protected static $keyMap = array();
/**
* @var int The number of the upload part representing its order in the overall upload
*/
protected $partNumber;
/**
* {@inheritdoc}
*/
public static function fromArray($data)
{
$part = new static();
$part->loadData($data);
return $part;
}
/**
* {@inheritdoc}
*/
public function getPartNumber()
{
return $this->partNumber;
}
/**
* {@inheritdoc}
*/
public function toArray()
{
$array = array();
foreach (static::$keyMap as $key => $property) {
$array[$key] = $this->{$property};
}
return $array;
}
/**
* {@inheritdoc}
*/
public function serialize()
{
return serialize($this->toArray());
}
/**
* {@inheritdoc}
*/
public function unserialize($serialized)
{
$this->loadData(unserialize($serialized));
}
/**
* Loads an array of data into the upload part by extracting only the needed keys
*
* @param array|\Traversable $data Data to load into the upload part value object
*
* @throws InvalidArgumentException if a required key is missing
*/
protected function loadData($data)
{
foreach (static::$keyMap as $key => $property) {
if (isset($data[$key])) {
$this->{$property} = $data[$key];
} else {
throw new InvalidArgumentException("A required key [$key] was missing from the upload part.");
}
}
}
}
MultipartUpload/UploadPartInterface.php 0000604 00000002351 15244442376 0014307 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
/**
* An object that encapsulates the data for an upload part
*/
interface UploadPartInterface extends \Serializable
{
/**
* Create an upload part from an array
*
* @param array|\Traversable $data Data representing the upload part
*
* @return self
*/
public static function fromArray($data);
/**
* Returns the part number of the upload part which is used as an identifier
*
* @return int
*/
public function getPartNumber();
/**
* Returns the array form of the upload part
*
* @return array
*/
public function toArray();
}
MultipartUpload/TransferStateInterface.php 0000604 00000004607 15244442376 0015027 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Client\AwsClientInterface;
/**
* State of a multipart upload
*/
interface TransferStateInterface extends \Countable, \IteratorAggregate, \Serializable
{
/**
* Create the transfer state from the results of list parts request
*
* @param AwsClientInterface $client Client used to send the request
* @param UploadIdInterface $uploadId Params needed to identify the upload and form the request
*
* @return self
*/
public static function fromUploadId(AwsClientInterface $client, UploadIdInterface $uploadId);
/**
* Get the params used to identify an upload part
*
* @return UploadIdInterface
*/
public function getUploadId();
/**
* Get the part information of a specific part
*
* @param int $partNumber Part to retrieve
*
* @return UploadPartInterface
*/
public function getPart($partNumber);
/**
* Add a part to the transfer state
*
* @param UploadPartInterface $part The part to add
*
* @return self
*/
public function addPart(UploadPartInterface $part);
/**
* Check if a specific part has been uploaded
*
* @param int $partNumber Part to check
*
* @return bool
*/
public function hasPart($partNumber);
/**
* Get a list of all of the uploaded part numbers
*
* @return array
*/
public function getPartNumbers();
/**
* Set whether or not the transfer has been aborted
*
* @param bool $aborted Set to true to mark the transfer as aborted
*
* @return self
*/
public function setAborted($aborted);
/**
* Check if the transfer has been marked as aborted
*
* @return bool
*/
public function isAborted();
}
MultipartUpload/AbstractUploadId.php 0000604 00000004356 15244442376 0013607 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Exception\InvalidArgumentException;
/**
* An object that encapsulates the data identifying an upload
*/
abstract class AbstractUploadId implements UploadIdInterface
{
/**
* @var array Expected values (with defaults)
*/
protected static $expectedValues = array();
/**
* @var array Params representing the identifying information
*/
protected $data = array();
/**
* {@inheritdoc}
*/
public static function fromParams($data)
{
$uploadId = new static();
$uploadId->loadData($data);
return $uploadId;
}
/**
* {@inheritdoc}
*/
public function toParams()
{
return $this->data;
}
/**
* {@inheritdoc}
*/
public function serialize()
{
return serialize($this->data);
}
/**
* {@inheritdoc}
*/
public function unserialize($serialized)
{
$this->loadData(unserialize($serialized));
}
/**
* Loads an array of data into the UploadId by extracting only the needed keys
*
* @param array $data Data to load
*
* @throws InvalidArgumentException if a required key is missing
*/
protected function loadData($data)
{
$data = array_replace(static::$expectedValues, array_intersect_key($data, static::$expectedValues));
foreach ($data as $key => $value) {
if (isset($data[$key])) {
$this->data[$key] = $data[$key];
} else {
throw new InvalidArgumentException("A required key [$key] was missing from the UploadId.");
}
}
}
}
MultipartUpload/TransferInterface.php 0000604 00000003517 15244442376 0014025 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Guzzle\Common\HasDispatcherInterface;
use Guzzle\Service\Resource\Model;
/**
* Interface for transferring the contents of a data source to an AWS service via a multipart upload interface
*/
interface TransferInterface extends HasDispatcherInterface
{
/**
* Upload the source to using a multipart upload
*
* @return Model|null Result of the complete multipart upload command or null if uploading was stopped
*/
public function upload();
/**
* Abort the upload
*
* @return Model Returns the result of the abort multipart upload command
*/
public function abort();
/**
* Get the current state of the upload
*
* @return TransferStateInterface
*/
public function getState();
/**
* Stop the transfer and retrieve the current state.
*
* This allows you to stop and later resume a long running transfer if needed.
*
* @return TransferStateInterface
*/
public function stop();
/**
* Set an option on the transfer object
*
* @param string $option Option to set
* @param mixed $value The value to set
*
* @return self
*/
public function setOption($option, $value);
}
MultipartUpload/AbstractTransferState.php 0000604 00000007065 15244442376 0014673 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
use Aws\Common\Exception\RuntimeException;
/**
* State of a multipart upload
*/
abstract class AbstractTransferState implements TransferStateInterface
{
/**
* @var UploadIdInterface Object holding params used to identity the upload part
*/
protected $uploadId;
/**
* @var array Array of parts where the part number is the index
*/
protected $parts = array();
/**
* @var bool Whether or not the transfer was aborted
*/
protected $aborted = false;
/**
* Construct a new transfer state object
*
* @param UploadIdInterface $uploadId Upload identifier object
*/
public function __construct(UploadIdInterface $uploadId)
{
$this->uploadId = $uploadId;
}
/**
* {@inheritdoc}
*/
public function getUploadId()
{
return $this->uploadId;
}
/**
* Get a data value from the transfer state's uploadId
*
* @param string $key Key to retrieve (e.g. Bucket, Key, UploadId, etc)
*
* @return string|null
*/
public function getFromId($key)
{
$params = $this->uploadId->toParams();
return isset($params[$key]) ? $params[$key] : null;
}
/**
* {@inheritdoc}
*/
public function getPart($partNumber)
{
return isset($this->parts[$partNumber]) ? $this->parts[$partNumber] : null;
}
/**
* {@inheritdoc}
*/
public function addPart(UploadPartInterface $part)
{
$partNumber = $part->getPartNumber();
$this->parts[$partNumber] = $part;
return $this;
}
/**
* {@inheritdoc}
*/
public function hasPart($partNumber)
{
return isset($this->parts[$partNumber]);
}
/**
* {@inheritdoc}
*/
public function getPartNumbers()
{
return array_keys($this->parts);
}
/**
* {@inheritdoc}
*/
public function setAborted($aborted)
{
$this->aborted = (bool) $aborted;
return $this;
}
/**
* {@inheritdoc}
*/
public function isAborted()
{
return $this->aborted;
}
/**
* {@inheritdoc}
*/
public function count()
{
return count($this->parts);
}
/**
* {@inheritdoc}
*/
public function getIterator()
{
return new \ArrayIterator($this->parts);
}
/**
* {@inheritdoc}
*/
public function serialize()
{
return serialize(get_object_vars($this));
}
/**
* {@inheritdoc}
*/
public function unserialize($serialized)
{
$data = unserialize($serialized);
foreach (get_object_vars($this) as $property => $oldValue) {
if (array_key_exists($property, $data)) {
$this->{$property} = $data[$property];
} else {
throw new RuntimeException("The {$property} property could be restored during unserialization.");
}
}
}
}
MultipartUpload/UploadIdInterface.php 0000604 00000002151 15244442376 0013733 0 ustar 00 <?php
/**
* Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
namespace Aws\Common\Model\MultipartUpload;
/**
* An object that encapsulates the data identifying an upload
*/
interface UploadIdInterface extends \Serializable
{
/**
* Create an UploadId from an array
*
* @param array $data Data representing the upload identification
*
* @return self
*/
public static function fromParams($data);
/**
* Returns the array form of the upload identification for use as command params
*
* @return array
*/
public function toParams();
}