Gaufrette\Adapter\AwsS3

Complexity

Total Complexity

56

Size/Duplication

Total Lines	377
Duplicated Lines	17.24 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	1
A	setMetadata()	0	10	2
A	getMetadata()	0	4	2
B	read()	0	24	6
B	rename()	0	24	4
B	write()	0	29	5
A	exists()	0	10	2
A	mtime()	14	14	4
A	size()	14	14	4
A	keys()	0	4	1
A	listKeys()	0	22	3
A	delete()	14	14	4
A	isDirectory()	0	15	4
B	ensureBucketExists()	0	25	4
A	getOptions()	0	14	1
A	computePath()	0	8	2
A	computeKey()	0	4	1
A	guessContentType()	10	10	2
A	mimeType()	13	13	4

<?php

namespace Gaufrette\Adapter;

use Aws\S3\Exception\S3Exception;
use Gaufrette\Adapter;
use Aws\S3\S3Client;
use Gaufrette\Exception\FileNotFound;
use Gaufrette\Exception\StorageFailure;
use Gaufrette\Util;

/**
 * Amazon S3 adapter using the AWS SDK for PHP v2.x.
 *
 * @author  Michael Dowling <mtdowling@gmail.com>
 */
class AwsS3 implements Adapter,

The first item in a multi-line implements list must be on the line following the implements keyword

                       MetadataSupporter,

Expected 4 spaces before interface name; 23 found

                       ListKeysAware,

Expected 4 spaces before interface name; 23 found

                       SizeCalculator,

Expected 4 spaces before interface name; 23 found

                       MimeTypeProvider

Expected 4 spaces before interface name; 23 found

{
    /** @var S3Client */
    protected $service;
    /** @var string */
    protected $bucket;
    /** @var array */
    protected $options;
    /** @var bool */
    protected $bucketExists;
    /** @var array */
    protected $metadata = [];
    /** @var bool */
    protected $detectContentType;

    /**
     * @param S3Client $service
     * @param string   $bucket
     * @param array    $options
     * @param bool     $detectContentType
     */
    public function __construct(S3Client $service, $bucket, array $options = [], $detectContentType = false)
    {
        $this->service = $service;
        $this->bucket = $bucket;
        $this->options = array_replace(
            [
                'create' => false,
                'directory' => '',
                'acl' => 'private',
            ],
            $options
        );

        // Remove trailing slash so it can't be doubled in computePath() method
        $this->options['directory'] = rtrim($this->options['directory'], '/');

        $this->detectContentType = $detectContentType;
    }

    /**
     * {@inheritdoc}
     */
    public function setMetadata($key, $metadata)
    {
        // BC with AmazonS3 adapter
        if (isset($metadata['contentType'])) {
            $metadata['ContentType'] = $metadata['contentType'];
            unset($metadata['contentType']);
        }

        $this->metadata[$key] = $metadata;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($key)
    {
        return isset($this->metadata[$key]) ? $this->metadata[$key] : [];
    }

    /**
     * {@inheritdoc}
     */
    public function read($key)
    {
        $this->ensureBucketExists();
        $options = $this->getOptions($key);

        try {
            // Get remote object
            $object = $this->service->getObject($options);
            // If there's no metadata array set up for this object, set it up
            if (!array_key_exists($key, $this->metadata) || !is_array($this->metadata[$key])) {
                $this->metadata[$key] = [];
            }
            // Make remote ContentType metadata available locally
            $this->metadata[$key]['ContentType'] = $object->get('ContentType');

            return (string) $object->get('Body');
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($key);
            }

            throw StorageFailure::unexpectedFailure('read', ['key' => $key], $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function rename($sourceKey, $targetKey)
    {
        $this->ensureBucketExists();
        $options = $this->getOptions(
            $targetKey,
            ['CopySource' => $this->bucket.'/'.$this->computePath($sourceKey)]
        );

        try {
            $this->service->copyObject(array_merge($options, $this->getMetadata($targetKey)));

            return $this->delete($sourceKey);
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($sourceKey);
            }

            throw StorageFailure::unexpectedFailure(
                'rename',
                ['sourceKey' => $sourceKey, 'targetKey' => $targetKey],
                $e
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function write($key, $content)
    {
        $this->ensureBucketExists();
        $options = $this->getOptions($key, ['Body' => $content]);

        /*
         * If the ContentType was not already set in the metadata, then we autodetect
         * it to prevent everything being served up as binary/octet-stream.
         */
        if (!isset($options['ContentType']) && $this->detectContentType) {
            $options['ContentType'] = $this->guessContentType($content);
        }

        try {
            $this->service->putObject($options);

            if (is_resource($content)) {
                return Util\Size::fromResource($content);
            }

            return Util\Size::fromContent($content);
        } catch (\Exception $e) {
            throw StorageFailure::unexpectedFailure(
                'write',
                ['key' => $key, 'content' => $content],
                $e
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function exists($key)
    {
        $path = $this->computePath($key);

        try {
            return $this->service->doesObjectExist($this->bucket, $path);
        } catch (\Exception $exception) {
            throw StorageFailure::unexpectedFailure('exists', ['key' => $key], $exception);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function mtime($key)

This method seems to be duplicated in your project.

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));

            return strtotime($result['LastModified']);
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($key);
            }

            throw StorageFailure::unexpectedFailure('mtime', ['key' => $key], $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function size($key)

This method seems to be duplicated in your project.

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));

            return $result['ContentLength'];
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($key);
            }

            throw StorageFailure::unexpectedFailure('size', ['key' => $key], $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function keys()
    {
        return $this->listKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function listKeys($prefix = '')
    {
        $this->ensureBucketExists();

        $options = [
            'Bucket' => $this->bucket,
            'Prefix' => $this->computePath($prefix),
        ];

        $keys = [];
        $objects = $this->service->getIterator('ListObjects', $options);

        try {
            foreach ($objects as $file) {
                $keys[] = $this->computeKey($file['Key']);
            }
        } catch (S3Exception $e) {
            throw StorageFailure::unexpectedFailure('listKeys', ['prefix' => $prefix], $e);
        }

        return $keys;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)

This method seems to be duplicated in your project.

    {
        try {
            $this->service->deleteObject($this->getOptions($key));

            return true;
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($key);
            }

            throw StorageFailure::unexpectedFailure('delete', ['key' => $key], $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function isDirectory($key)
    {
        $result = $this->service->listObjects([
            'Bucket' => $this->bucket,
            'Prefix' => rtrim($this->computePath($key), '/').'/',
            'MaxKeys' => 1,
        ]);
        if (isset($result['Contents'])) {
            if (is_array($result['Contents']) || $result['Contents'] instanceof \Countable) {
                return count($result['Contents']) > 0;
            }
        }

        return false;
    }

    /**
     * Ensures the specified bucket exists. If the bucket does not exists
     * and the create option is set to true, it will try to create the
     * bucket. The bucket is created using the same region as the supplied
     * client object.
     *
     * @throws \RuntimeException if the bucket does not exists or could not be
     *                           created
     */
    protected function ensureBucketExists()
    {
        if ($this->bucketExists) {
            return true;
        }

        if ($this->bucketExists = $this->service->doesBucketExist($this->bucket)) {
            return true;
        }

        if (!$this->options['create']) {
            throw new \RuntimeException(sprintf(
                'The configured bucket "%s" does not exist.',
                $this->bucket
            ));
        }

        $this->service->createBucket([
            'Bucket' => $this->bucket,
            'LocationConstraint' => $this->service->getRegion()
        ]);
        $this->bucketExists = true;

        return true;
    }

    protected function getOptions($key, array $options = [])
    {
        $options['ACL'] = $this->options['acl'];
        $options['Bucket'] = $this->bucket;
        $options['Key'] = $this->computePath($key);

        /*
         * Merge global options for adapter, which are set in the constructor, with metadata.
         * Metadata will override global options.
         */
        $options = array_merge($this->options, $options, $this->getMetadata($key));

        return $options;
    }

    protected function computePath($key)
    {
        if (empty($this->options['directory'])) {
            return $key;
        }

        return sprintf('%s/%s', $this->options['directory'], $key);
    }

    /**
     * Computes the key from the specified path.
     *
     * @param string $path
     *
     * return string
     */
    protected function computeKey($path)
    {
        return ltrim(substr($path, strlen($this->options['directory'])), '/');
    }

    /**
     * @param string $content
     *
     * @return string
     */
    private function guessContentType($content)

This method seems to be duplicated in your project.

    {
        $fileInfo = new \finfo(FILEINFO_MIME_TYPE);

        if (is_resource($content)) {
            return $fileInfo->file(stream_get_meta_data($content)['uri']);
        }

        return $fileInfo->buffer($content);
    }

    public function mimeType($key)

This method seems to be duplicated in your project.

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));
            return ($result['ContentType']);
        } catch (\Exception $e) {
            if ($e instanceof S3Exception && $e->getResponse()->getStatusCode() === 404) {
                throw new FileNotFound($key);
            }

            throw StorageFailure::unexpectedFailure('mimeType', ['key' => $key], $e);
        }
    }
}