public function __construct($params)
{
if (!isset($params['key']) || !isset($params['secret']) || !isset($params['bucket'])) {
throw new \Exception("Access Key, Secret and Bucket have to be configured.");
}
$this->id = 'amazon::' . $params['key'] . md5($params['secret']);
$this->bucket = $params['bucket'];
$scheme = $params['use_ssl'] === 'false' ? 'http' : 'https';
$this->test = isset($params['test']);
$this->timeout = !isset($params['timeout']) ? 15 : $params['timeout'];
$params['region'] = !isset($params['region']) || $params['region'] === '' ? 'eu-west-1' : $params['region'];
$params['hostname'] = !isset($params['hostname']) || $params['hostname'] === '' ? 's3.amazonaws.com' : $params['hostname'];
if (!isset($params['port']) || $params['port'] === '') {
$params['port'] = $params['use_ssl'] === 'false' ? 80 : 443;
}
$base_url = $scheme . '://' . $params['hostname'] . ':' . $params['port'] . '/';
$this->connection = S3Client::factory(array('key' => $params['key'], 'secret' => $params['secret'], 'base_url' => $base_url, 'region' => $params['region']));
if (!$this->connection->isValidBucketName($this->bucket)) {
throw new \Exception("The configured bucket name is invalid.");
}
if (!$this->connection->doesBucketExist($this->bucket)) {
try {
$result = $this->connection->createBucket(array('Bucket' => $this->bucket));
$this->connection->waitUntilBucketExists(array('Bucket' => $this->bucket, 'waiter.interval' => 1, 'waiter.max_attempts' => 15));
$this->testTimeout();
} catch (S3Exception $e) {
\OCP\Util::writeLog('files_external', $e->getMessage(), \OCP\Util::ERROR);
throw new \Exception("Creation of bucket failed.");
}
}
if (!$this->file_exists('.')) {
$result = $this->connection->putObject(array('Bucket' => $this->bucket, 'Key' => '.', 'Body' => '', 'ContentType' => 'httpd/unix-directory', 'ContentLength' => 0));
$this->testTimeout();
}
}
/**
* Attempt to build a bucket (if it doesn't already exist).
*
* @param string $bucketName
*/
protected function buildBucket($bucketName)
{
if (!$this->s3Client->doesBucketExist($bucketName, true)) {
$this->s3Client->createBucket(['ACL' => $this->attachedFile->ACL, 'Bucket' => $bucketName, 'LocationConstraint' => $this->attachedFile->region]);
}
$this->bucketExists = true;
}
/**
* Update a container with some properties
*
* @param string $container
* @param array $properties
*
* @throws DfException
* @return void
*/
public function updateContainerProperties($container, $properties = [])
{
$this->checkConnection();
try {
if ($this->blobConn->doesBucketExist($container)) {
throw new \Exception("No container named '{$container}'");
}
} catch (\Exception $ex) {
throw new DfException("Failed to update container '{$container}': " . $ex->getMessage());
}
}
/**
* Execute the DescribeTrails and DeleteTrail operations
*
* @example Aws\CloudTrail\CloudTrailClient::deleteTrail
* @example Aws\CloudTrail\CloudTrailClient::getDescribeTrailsIterator
* @depends testStopLogging
*/
public function testDeleteTrails($bucket)
{
$client = $this->cloudtrail;
// @begin
// List and delete all of the trails
$trails = $client->getDescribeTrailsIterator();
foreach ($trails as $trail) {
$client->deleteTrail(array('Name' => $trail['Name']));
echo "Deleted trail {$trail['Name']}.\n";
}
// @end
$this->assertEquals("Deleted trail test-trail.\n", $this->getActualOutput());
// Clean up test bucket
sleep(5);
if ($this->s3->doesBucketExist($bucket)) {
$this->s3->clearBucket($bucket);
$this->s3->deleteBucket(array('Bucket' => $bucket));
}
}
protected function saveImage(array $file, $subdirectory = '')
{
$s3 = new S3Client(['version' => 'latest', 'region' => 'eu-west-1']);
$subdirectory = trim($subdirectory, '/');
list($name, $extension) = explode('.', trim($file['name'], '/'));
$filename = md5((string) rand()) . '.' . $extension;
$directory = self::$public_image_directory . '/' . $subdirectory . '/';
$bucket_name = 'comp3013';
if (!$s3->doesBucketExist($bucket_name)) {
echo 'Error, bucket didnt exist';
exit(0);
}
while ($s3->doesObjectExist($bucket_name, $directory . $filename)) {
$filename = md5((string) rand()) . '.' . $extension;
}
$parameters = ['ContentType' => $file['type'], 'Bucket' => $bucket_name, 'Key' => $directory . $filename, 'SourceFile' => $file['tmp_name']];
print_r($parameters);
$s3->putObject($parameters);
$s3->waitUntil('ObjectExists', ['Bucket' => $bucket_name, 'Key' => $directory . $filename]);
//exit(0);
return 'http://comp3013.s3-website-eu-west-1.amazonaws.com/' . $directory . $filename;
}
/**
* Returns the connection
*
* @return S3Client connected client
* @throws \Exception if connection could not be made
*/
public function getConnection() {
if (!is_null($this->connection)) {
return $this->connection;
}
$scheme = ($this->params['use_ssl'] === 'false') ? 'http' : 'https';
$base_url = $scheme . '://' . $this->params['hostname'] . ':' . $this->params['port'] . '/';
$this->connection = S3Client::factory(array(
'key' => $this->params['key'],
'secret' => $this->params['secret'],
'base_url' => $base_url,
'region' => $this->params['region']
));
if (!$this->connection->isValidBucketName($this->bucket)) {
throw new \Exception("The configured bucket name is invalid.");
}
if (!$this->connection->doesBucketExist($this->bucket)) {
try {
$this->connection->createBucket(array(
'Bucket' => $this->bucket
));
$this->connection->waitUntilBucketExists(array(
'Bucket' => $this->bucket,
'waiter.interval' => 1,
'waiter.max_attempts' => 15
));
$this->testTimeout();
} catch (S3Exception $e) {
\OCP\Util::logException('files_external', $e);
throw new \Exception('Creation of bucket failed. '.$e->getMessage());
}
}
return $this->connection;
}
/**
* Validate that a bucket exists.
*
* Since bucket names are global across all of S3, we can't determine if a
* bucket doesn't exist at all, or if it exists but is owned by another S3
* account.
*
* @param string $bucket
* The name of the bucket to test.
* @param \Aws\S3\S3Client $client
* The S3Client to use.
*
* @throws S3ConnectValidationException
* Thrown when credentials are invalid or the bucket does not exist.
*/
public static function validateBucketExists($bucket, \Aws\S3\S3Client $client)
{
if (!$client->doesBucketExist($bucket, FALSE)) {
throw new S3ConnectValidationException('The S3 access credentials are invalid or the bucket does not exist.');
}
}
/**
* Determines whether or not a bucket exists by name
*
* @param string $bucket The name of the bucket
* @param bool $accept403 Set to true if 403s are acceptable
* @param array $params Additional options to add to the executed command
*
* @return bool
*/
public function doesBucketExist($bucket, $accept403 = true, array $params = [])
{
return $this->instance->doesBucketExist($bucket, $accept403, $params);
}
/**
* exist
*
* @param boolean $accept403
* @param array $options
*
* @return boolean
*/
public function exist($accept403 = true, array $options = array())
{
return $this->client->doesBucketExist($this->name, $accept403, $options);
}
protected function verifyBucketExists(S3Client $s3Client)
{
if (!strlen($this->bucketName)) {
throw new Exception("[S3Sync::verifyBucketExists] Unable to verify S3 bucket: bucket name not set");
}
if (!$s3Client->doesBucketExist($this->bucketName)) {
$result = $s3Client->createBucket(array('ACL' => 'private', 'Bucket' => $this->bucketName));
$s3Client->waitUntilBucketExists(array('Bucket' => $this->bucketName));
if (!$s3Client->doesBucketExist($this->bucketName)) {
throw new Exception('[S3Sync::verifyBucketExists] Unable to create S3 bucket ' . $this->bucketName);
}
}
return true;
}
/**
* _createBucket
* Create the bucket, if not exists, for Amazon S3
*
* @param string $bucketName name of the bucket.
* @return void
*/
protected function _createBucket($bucketName)
{
//TODO: migliorare con un ritorno di qualcosa...
if (!$this->_s3Client->doesBucketExist($bucketName)) {
$this->_s3Client->createBucket(array('Bucket' => $bucketName));
}
// Poll the bucket until it is accessible
$this->_s3Client->waitUntil('BucketExists', array('Bucket' => $bucketName));
}
public function doesBucketExist($bucket)
{
return $this->s3->doesBucketExist($bucket);
}
