ok
Mini Shell
<?php
namespace Aws\S3;
use Aws\Api\Parser\PayloadParserTrait;
use Aws\CommandInterface;
use Aws\Exception\AwsException;
use Aws\HandlerList;
use Aws\ResultInterface;
use Aws\S3\Exception\PermanentRedirectException;
use Aws\S3\Exception\S3Exception;
use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Promise\RejectedPromise;
use Psr\Http\Message\ResponseInterface;
/**
* A trait providing S3-specific functionality. This is meant to be used in
* classes implementing \Aws\S3\S3ClientInterface
*/
trait S3ClientTrait
{
use PayloadParserTrait;
/**
* @see S3ClientInterface::upload()
*/
public function upload(
$bucket,
$key,
$body,
$acl = 'private',
array $options = []
) {
return $this
->uploadAsync($bucket, $key, $body, $acl, $options)
->wait();
}
/**
* @see S3ClientInterface::uploadAsync()
*/
public function uploadAsync(
$bucket,
$key,
$body,
$acl = 'private',
array $options = []
) {
return (new ObjectUploader($this, $bucket, $key, $body, $acl, $options))
->promise();
}
/**
* @see S3ClientInterface::copy()
*/
public function copy(
$fromB,
$fromK,
$destB,
$destK,
$acl = 'private',
array $opts = []
) {
return $this->copyAsync($fromB, $fromK, $destB, $destK, $acl, $opts)
->wait();
}
/**
* @see S3ClientInterface::copyAsync()
*/
public function copyAsync(
$fromB,
$fromK,
$destB,
$destK,
$acl = 'private',
array $opts = []
) {
$source = [
'Bucket' => $fromB,
'Key' => $fromK,
];
if (isset($opts['version_id'])) {
$source['VersionId'] = $opts['version_id'];
}
$destination = [
'Bucket' => $destB,
'Key' => $destK
];
return (new ObjectCopier($this, $source, $destination, $acl, $opts))
->promise();
}
/**
* @see S3ClientInterface::registerStreamWrapper()
*/
public function registerStreamWrapper()
{
StreamWrapper::register($this);
}
/**
* @see S3ClientInterface::registerStreamWrapperV2()
*/
public function registerStreamWrapperV2()
{
StreamWrapper::register(
$this,
's3',
null,
true
);
}
/**
* @see S3ClientInterface::deleteMatchingObjects()
*/
public function deleteMatchingObjects(
$bucket,
$prefix = '',
$regex = '',
array $options = []
) {
$this->deleteMatchingObjectsAsync($bucket, $prefix, $regex, $options)
->wait();
}
/**
* @see S3ClientInterface::deleteMatchingObjectsAsync()
*/
public function deleteMatchingObjectsAsync(
$bucket,
$prefix = '',
$regex = '',
array $options = []
) {
if (!$prefix && !$regex) {
return new RejectedPromise(
new \RuntimeException('A prefix or regex is required.')
);
}
$params = ['Bucket' => $bucket, 'Prefix' => $prefix];
$iter = $this->getIterator('ListObjects', $params);
if ($regex) {
$iter = \Aws\filter($iter, function ($c) use ($regex) {
return preg_match($regex, $c['Key']);
});
}
return BatchDelete::fromIterator($this, $bucket, $iter, $options)
->promise();
}
/**
* @see S3ClientInterface::uploadDirectory()
*/
public function uploadDirectory(
$directory,
$bucket,
$keyPrefix = null,
array $options = []
) {
$this->uploadDirectoryAsync($directory, $bucket, $keyPrefix, $options)
->wait();
}
/**
* @see S3ClientInterface::uploadDirectoryAsync()
*/
public function uploadDirectoryAsync(
$directory,
$bucket,
$keyPrefix = null,
array $options = []
) {
$d = "s3://$bucket" . ($keyPrefix ? '/' . ltrim($keyPrefix, '/') : '');
return (new Transfer($this, $directory, $d, $options))->promise();
}
/**
* @see S3ClientInterface::downloadBucket()
*/
public function downloadBucket(
$directory,
$bucket,
$keyPrefix = '',
array $options = []
) {
$this->downloadBucketAsync($directory, $bucket, $keyPrefix, $options)
->wait();
}
/**
* @see S3ClientInterface::downloadBucketAsync()
*/
public function downloadBucketAsync(
$directory,
$bucket,
$keyPrefix = '',
array $options = []
) {
$s = "s3://$bucket" . ($keyPrefix ? '/' . ltrim($keyPrefix, '/') : '');
return (new Transfer($this, $s, $directory, $options))->promise();
}
/**
* @see S3ClientInterface::determineBucketRegion()
*/
public function determineBucketRegion($bucketName)
{
return $this->determineBucketRegionAsync($bucketName)->wait();
}
/**
* @see S3ClientInterface::determineBucketRegionAsync()
*
* @param string $bucketName
*
* @return PromiseInterface
*/
public function determineBucketRegionAsync($bucketName)
{
$command = $this->getCommand('HeadBucket', ['Bucket' => $bucketName]);
$handlerList = clone $this->getHandlerList();
$handlerList->remove('s3.permanent_redirect');
$handlerList->remove('signer');
$handler = $handlerList->resolve();
return $handler($command)
->then(static function (ResultInterface $result) {
return $result['@metadata']['headers']['x-amz-bucket-region'];
}, function (AwsException $e) {
$response = $e->getResponse();
if ($response === null) {
throw $e;
}
if ($e->getAwsErrorCode() === 'AuthorizationHeaderMalformed') {
$region = $this->determineBucketRegionFromExceptionBody(
$response
);
if (!empty($region)) {
return $region;
}
throw $e;
}
return $response->getHeaderLine('x-amz-bucket-region');
});
}
private function determineBucketRegionFromExceptionBody(ResponseInterface $response)
{
try {
$element = $this->parseXml($response->getBody(), $response);
if (!empty($element->Region)) {
return (string)$element->Region;
}
} catch (\Exception $e) {
// Fallthrough on exceptions from parsing
}
return false;
}
/**
* @see S3ClientInterface::doesBucketExist()
*/
public function doesBucketExist($bucket)
{
return $this->checkExistenceWithCommand(
$this->getCommand('HeadBucket', ['Bucket' => $bucket])
);
}
/**
* @see S3ClientInterface::doesBucketExistV2()
*/
public function doesBucketExistV2($bucket, $accept403 = false)
{
$command = $this->getCommand('HeadBucket', ['Bucket' => $bucket]);
try {
$this->execute($command);
return true;
} catch (S3Exception $e) {
if (
($accept403 && $e->getStatusCode() === 403)
|| $e instanceof PermanentRedirectException
) {
return true;
}
if ($e->getStatusCode() === 404) {
return false;
}
throw $e;
}
}
/**
* @see S3ClientInterface::doesObjectExist()
*/
public function doesObjectExist($bucket, $key, array $options = [])
{
return $this->checkExistenceWithCommand(
$this->getCommand('HeadObject', [
'Bucket' => $bucket,
'Key' => $key
] + $options)
);
}
/**
* @see S3ClientInterface::doesObjectExistV2()
*/
public function doesObjectExistV2(
$bucket,
$key,
$includeDeleteMarkers = false,
array $options = []
){
$command = $this->getCommand('HeadObject', [
'Bucket' => $bucket,
'Key' => $key
] + $options
);
try {
$this->execute($command);
return true;
} catch (S3Exception $e) {
if ($includeDeleteMarkers
&& $this->useDeleteMarkers($e)
) {
return true;
}
if ($e->getStatusCode() === 404) {
return false;
}
throw $e;
}
}
private function useDeleteMarkers($exception)
{
$response = $exception->getResponse();
return !empty($response)
&& $response->getHeader('x-amz-delete-marker');
}
/**
* Determines whether or not a resource exists using a command
*
* @param CommandInterface $command Command used to poll for the resource
*
* @return bool
* @throws S3Exception|\Exception if there is an unhandled exception
*/
private function checkExistenceWithCommand(CommandInterface $command)
{
try {
$this->execute($command);
return true;
} catch (S3Exception $e) {
if ($e->getAwsErrorCode() == 'AccessDenied') {
return true;
}
if ($e->getStatusCode() >= 500) {
throw $e;
}
return false;
}
}
/**
* @see S3ClientInterface::execute()
*/
abstract public function execute(CommandInterface $command);
/**
* @see S3ClientInterface::getCommand()
*/
abstract public function getCommand($name, array $args = []);
/**
* @see S3ClientInterface::getHandlerList()
*
* @return HandlerList
*/
abstract public function getHandlerList();
/**
* @see S3ClientInterface::getIterator()
*
* @return \Iterator
*/
abstract public function getIterator($name, array $args = []);
}
Zerion Mini Shell 1.0