Proyectos de Subversion Moodle

<?php

namespace Aws\S3;

use Aws\CacheInterface;

use Aws\LruArrayCache;

use Aws\Result;

use Aws\S3\Exception\S3Exception;

use GuzzleHttp\Psr7;

use GuzzleHttp\Psr7\Stream;

use GuzzleHttp\Psr7\CachingStream;

use Psr\Http\Message\StreamInterface;

/**

 * Amazon S3 stream wrapper to use "s3://<bucket>/<key>" files with PHP

 * streams, supporting "r", "w", "a", "x".

 *

 * # Opening "r" (read only) streams:

 *

 * Read only streams are truly streaming by default and will not allow you to

 * seek. This is because data read from the stream is not kept in memory or on

 * the local filesystem. You can force a "r" stream to be seekable by setting

 * the "seekable" stream context option true. This will allow true streaming of

 * data from Amazon S3, but will maintain a buffer of previously read bytes in

 * a 'php://temp' stream to allow seeking to previously read bytes from the

 * stream.

 *

 * You may pass any GetObject parameters as 's3' stream context options. These

 * options will affect how the data is downloaded from Amazon S3.

 *

 * # Opening "w" and "x" (write only) streams:

 *

 * Because Amazon S3 requires a Content-Length header, write only streams will

 * maintain a 'php://temp' stream to buffer data written to the stream until

 * the stream is flushed (usually by closing the stream with fclose).

 *

 * You may pass any PutObject parameters as 's3' stream context options. These

 * options will affect how the data is uploaded to Amazon S3.

 *

 * When opening an "x" stream, the file must exist on Amazon S3 for the stream

 * to open successfully.

 *

 * # Opening "a" (write only append) streams:

 *

 * Similar to "w" streams, opening append streams requires that the data be

 * buffered in a "php://temp" stream. Append streams will attempt to download

 * the contents of an object in Amazon S3, seek to the end of the object, then

 * allow you to append to the contents of the object. The data will then be

 * uploaded using a PutObject operation when the stream is flushed (usually

 * with fclose).

 *

 * You may pass any GetObject and/or PutObject parameters as 's3' stream

 * context options. These options will affect how the data is downloaded and

 * uploaded from Amazon S3.

 *

 * Stream context options:

 *

 * - "seekable": Set to true to create a seekable "r" (read only) stream by

 *   using a php://temp stream buffer

 * - For "unlink" only: Any option that can be passed to the DeleteObject

 *   operation

 */

class StreamWrapper

{

    /** @var resource|null Stream context (this is set by PHP) */

    public $context;

    /** @var StreamInterface Underlying stream resource */

    private $body;

    /** @var int Size of the body that is opened */

    private $size;

    /** @var array Hash of opened stream parameters */

    private $params = [];

    /** @var string Mode in which the stream was opened */

    private $mode;

    /** @var \Iterator Iterator used with opendir() related calls */

    private $objectIterator;

    /** @var string The bucket that was opened when opendir() was called */

    private $openedBucket;

    /** @var string The prefix of the bucket that was opened with opendir() */

    private $openedBucketPrefix;

    /** @var string Opened bucket path */

    private $openedPath;

    /** @var CacheInterface Cache for object and dir lookups */

    private $cache;

    /** @var string The opened protocol (e.g., "s3") */

    private $protocol = 's3';

    /** @var bool Keeps track of whether stream has been flushed since opening */

    private $isFlushed = false;

    /** @var bool Whether or not to use V2 bucket and object existence methods */

    private static $useV2Existence = false;

    /**

     * Register the 's3://' stream wrapper

     *

     * @param S3ClientInterface $client   Client to use with the stream wrapper

     * @param string            $protocol Protocol to register as.

     * @param CacheInterface    $cache    Default cache for the protocol.

     */

    public static function register(

        S3ClientInterface $client,

        $protocol = 's3',

        ?CacheInterface $cache = null,

        $v2Existence = false

    ) {

        self::$useV2Existence = $v2Existence;

        if (in_array($protocol, stream_get_wrappers())) {

            stream_wrapper_unregister($protocol);

        }

        // Set the client passed in as the default stream context client

        stream_wrapper_register($protocol, get_called_class(), STREAM_IS_URL);

        $default = stream_context_get_options(stream_context_get_default());

        $default[$protocol]['client'] = $client;

        if ($cache) {

            $default[$protocol]['cache'] = $cache;

        } elseif (!isset($default[$protocol]['cache'])) {

            // Set a default cache adapter.

            $default[$protocol]['cache'] = new LruArrayCache();

        }

        stream_context_set_default($default);

    }

    public function stream_close()

    {

        if (!$this->isFlushed

            && empty($this->body->getSize())

            && $this->mode !== 'r'

        ) {

            $this->stream_flush();

        }

        $this->body = $this->cache = null;

    }

    public function stream_open($path, $mode, $options, &$opened_path)

    {

        $this->initProtocol($path);

        $this->isFlushed = false;

        $this->params = $this->getBucketKey($path);

        $this->mode = rtrim($mode, 'bt');

        if ($errors = $this->validate($path, $this->mode)) {

            return $this->triggerError($errors);

        }

        return $this->boolCall(function() {

            switch ($this->mode) {

                case 'r': return $this->openReadStream();

                case 'a': return $this->openAppendStream();

                default: return $this->openWriteStream();

            }

        });

    }

    public function stream_eof()

    {

        return $this->body->eof();

    }

    public function stream_flush()

    {

        // Check if stream body size has been

        // calculated via a flush or close

        if($this->body->getSize() === null && $this->mode !== 'r') {

            return $this->triggerError(

                "Unable to determine stream size. Did you forget to close or flush the stream?"

            );

        }

        $this->isFlushed = true;

        if ($this->mode == 'r') {

            return false;

        }

        if ($this->body->isSeekable()) {

            $this->body->seek(0);

        }

        $params = $this->getOptions(true);

        $params['Body'] = $this->body;

        // Attempt to guess the ContentType of the upload based on the

        // file extension of the key

        if (!isset($params['ContentType']) &&

            ($type = Psr7\MimeType::fromFilename($params['Key']))

        ) {

            $params['ContentType'] = $type;

        }

        $this->clearCacheKey("{$this->protocol}://{$params['Bucket']}/{$params['Key']}");

        return $this->boolCall(function () use ($params) {

            return (bool) $this->getClient()->putObject($params);

        });

    }

    public function stream_read($count)

    {

        return $this->body->read($count);

    }

    public function stream_seek($offset, $whence = SEEK_SET)

    {

        return !$this->body->isSeekable()

            ? false

            : $this->boolCall(function () use ($offset, $whence) {

                $this->body->seek($offset, $whence);

                return true;

            });

    }

    public function stream_tell()

    {

        return $this->boolCall(function() { return $this->body->tell(); });

    }

    public function stream_write($data)

    {

        return $this->body->write($data);

    }

    public function unlink($path)

    {

        $this->initProtocol($path);

        return $this->boolCall(function () use ($path) {

            $this->clearCacheKey($path);

            $this->getClient()->deleteObject($this->withPath($path));

            return true;

        });

    }

    public function stream_stat()

    {

        $stat = $this->getStatTemplate();

        $stat[7] = $stat['size'] = $this->getSize();

        $stat[2] = $stat['mode'] = $this->mode;

        return $stat;

    }

    /**

     * Provides information for is_dir, is_file, filesize, etc. Works on

     * buckets, keys, and prefixes.

     * @link http://www.php.net/manual/en/streamwrapper.url-stat.php

     */

    public function url_stat($path, $flags)

    {

        $this->initProtocol($path);

        // Some paths come through as S3:// for some reason.

        $split = explode('://', $path);

        $path = strtolower($split[0]) . '://' . $split[1];

        // Check if this path is in the url_stat cache

        if ($value = $this->getCacheStorage()->get($path)) {

            return $value;

        }

        $stat = $this->createStat($path, $flags);

        if (is_array($stat)) {

            $this->getCacheStorage()->set($path, $stat);

        }

        return $stat;

    }

    /**

     * Parse the protocol out of the given path.

     *

     * @param $path

     */

    private function initProtocol($path)

    {

        $parts = explode('://', $path, 2);

        $this->protocol = $parts[0] ?: 's3';

    }

    private function createStat($path, $flags)

    {

        $this->initProtocol($path);

        $parts = $this->withPath($path);

        if (!$parts['Key']) {

            return $this->statDirectory($parts, $path, $flags);

        }

        return $this->boolCall(function () use ($parts, $path) {

            try {

                $result = $this->getClient()->headObject($parts);

                if (substr($parts['Key'], -1, 1) == '/' &&

                    $result['ContentLength'] == 0

                ) {

                    // Return as if it is a bucket to account for console

                    // bucket objects (e.g., zero-byte object "foo/")

                    return $this->formatUrlStat($path);

                }

                // Attempt to stat and cache regular object

                return $this->formatUrlStat($result->toArray());

            } catch (S3Exception $e) {

                // Maybe this isn't an actual key, but a prefix. Do a prefix

                // listing of objects to determine.

                $result = $this->getClient()->listObjects([

                    'Bucket'  => $parts['Bucket'],

                    'Prefix'  => rtrim($parts['Key'], '/') . '/',

                    'MaxKeys' => 1

                ]);

                if (!$result['Contents'] && !$result['CommonPrefixes']) {

                    throw new \Exception("File or directory not found: $path");

                }

                return $this->formatUrlStat($path);

            }

        }, $flags);

    }

    private function statDirectory($parts, $path, $flags)

    {

        // Stat "directories": buckets, or "s3://"

        $method = self::$useV2Existence ? 'doesBucketExistV2' : 'doesBucketExist';

        if (!$parts['Bucket'] ||

            $this->getClient()->$method($parts['Bucket'])

        ) {

            return $this->formatUrlStat($path);

        }

        return $this->triggerError("File or directory not found: $path", $flags);

    }

    /**

     * Support for mkdir().

     *

     * @param string $path    Directory which should be created.

     * @param int    $mode    Permissions. 700-range permissions map to

     *                        ACL_PUBLIC. 600-range permissions map to

     *                        ACL_AUTH_READ. All other permissions map to

     *                        ACL_PRIVATE. Expects octal form.

     * @param int    $options A bitwise mask of values, such as

     *                        STREAM_MKDIR_RECURSIVE.

     *

     * @return bool

     * @link http://www.php.net/manual/en/streamwrapper.mkdir.php

     */

    public function mkdir($path, $mode, $options)

    {

        $this->initProtocol($path);

        $params = $this->withPath($path);

        $this->clearCacheKey($path);

        if (!$params['Bucket']) {

            return false;

        }

        if (!isset($params['ACL'])) {

            $params['ACL'] = $this->determineAcl($mode);

        }

        return empty($params['Key'])

            ? $this->createBucket($path, $params)

            : $this->createSubfolder($path, $params);

    }

    public function rmdir($path, $options)

    {

        $this->initProtocol($path);

        $this->clearCacheKey($path);

        $params = $this->withPath($path);

        $client = $this->getClient();

        if (!$params['Bucket']) {

            return $this->triggerError('You must specify a bucket');

        }

        return $this->boolCall(function () use ($params, $path, $client) {

            if (!$params['Key']) {

                $client->deleteBucket(['Bucket' => $params['Bucket']]);

                return true;

            }

            return $this->deleteSubfolder($path, $params);

        });

    }

    /**

     * Support for opendir().

     *

     * The opendir() method of the Amazon S3 stream wrapper supports a stream

     * context option of "listFilter". listFilter must be a callable that

     * accepts an associative array of object data and returns true if the

     * object should be yielded when iterating the keys in a bucket.

     *

     * @param string $path    The path to the directory

     *                        (e.g. "s3://dir[</prefix>]")

     * @param string $options Unused option variable

     *

     * @return bool true on success

     * @see http://www.php.net/manual/en/function.opendir.php

     */

    public function dir_opendir($path, $options)

    {

        $this->initProtocol($path);

        $this->openedPath = $path;

        $params = $this->withPath($path);

        $delimiter = $this->getOption('delimiter');

        /** @var callable $filterFn */

        $filterFn = $this->getOption('listFilter');

        $op = ['Bucket' => $params['Bucket']];

        $this->openedBucket = $params['Bucket'];

        if ($delimiter === null) {

            $delimiter = '/';

        }

        if ($delimiter) {

            $op['Delimiter'] = $delimiter;

        }

        if ($params['Key']) {

            $params['Key'] = rtrim($params['Key'], $delimiter) . $delimiter;

            $op['Prefix'] = $params['Key'];

        }

        $this->openedBucketPrefix = $params['Key'];

        // Filter our "/" keys added by the console as directories, and ensure

        // that if a filter function is provided that it passes the filter.

        $this->objectIterator = \Aws\flatmap(

            $this->getClient()->getPaginator('ListObjects', $op),

            function (Result $result) use ($filterFn) {

                $contentsAndPrefixes = $result->search('[Contents[], CommonPrefixes[]][]');

                // Filter out dir place holder keys and use the filter fn.

                return array_filter(

                    $contentsAndPrefixes,

                    function ($key) use ($filterFn) {

                        return (!$filterFn || call_user_func($filterFn, $key))

                            && (!isset($key['Key']) || substr($key['Key'], -1, 1) !== '/');

                    }

                );

            }

        );

        return true;

    }

    /**

     * Close the directory listing handles

     *

     * @return bool true on success

     */

    public function dir_closedir()

    {

        $this->objectIterator = null;

        gc_collect_cycles();

        return true;

    }

    /**

     * This method is called in response to rewinddir()

     *

     * @return boolean true on success

     */

    public function dir_rewinddir()

    {

        return $this->boolCall(function() {

            $this->objectIterator = null;

            $this->dir_opendir($this->openedPath, null);

            return true;

        });

    }

    /**

     * This method is called in response to readdir()

     *

     * @return string Should return a string representing the next filename, or

     *                false if there is no next file.

     * @link http://www.php.net/manual/en/function.readdir.php

     */

    public function dir_readdir()

    {

        // Skip empty result keys

        if (!$this->objectIterator->valid()) {

            return false;

        }

        // First we need to create a cache key. This key is the full path to

        // then object in s3: protocol://bucket/key.

        // Next we need to create a result value. The result value is the

        // current value of the iterator without the opened bucket prefix to

        // emulate how readdir() works on directories.

        // The cache key and result value will depend on if this is a prefix

        // or a key.

        $cur = $this->objectIterator->current();

        if (isset($cur['Prefix'])) {

            // Include "directories". Be sure to strip a trailing "/"

            // on prefixes.

            $result = rtrim($cur['Prefix'], '/');

            $key = $this->formatKey($result);

            $stat = $this->formatUrlStat($key);

        } else {

            $result = $cur['Key'];

            $key = $this->formatKey($cur['Key']);

            $stat = $this->formatUrlStat($cur);

        }

        // Cache the object data for quick url_stat lookups used with

        // RecursiveDirectoryIterator.

        $this->getCacheStorage()->set($key, $stat);

        $this->objectIterator->next();

        // Remove the prefix from the result to emulate other stream wrappers.

        return $this->openedBucketPrefix

            ? substr($result, strlen($this->openedBucketPrefix))

            : $result;

    }

    private function formatKey($key)

    {

        $protocol = explode('://', $this->openedPath)[0];

        return "{$protocol}://{$this->openedBucket}/{$key}";

    }

    /**

     * Called in response to rename() to rename a file or directory. Currently

     * only supports renaming objects.

     *

     * @param string $path_from the path to the file to rename

     * @param string $path_to   the new path to the file

     *

     * @return bool true if file was successfully renamed

     * @link http://www.php.net/manual/en/function.rename.php

     */

    public function rename($path_from, $path_to)

    {

        // PHP will not allow rename across wrapper types, so we can safely

        // assume $path_from and $path_to have the same protocol

        $this->initProtocol($path_from);

        $partsFrom = $this->withPath($path_from);

        $partsTo = $this->withPath($path_to);

        $this->clearCacheKey($path_from);

        $this->clearCacheKey($path_to);

        if (!$partsFrom['Key'] || !$partsTo['Key']) {

            return $this->triggerError('The Amazon S3 stream wrapper only '

                . 'supports copying objects');

        }

        return $this->boolCall(function () use ($partsFrom, $partsTo) {

            $options = $this->getOptions(true);

            // Copy the object and allow overriding default parameters if

            // desired, but by default copy metadata

            $this->getClient()->copy(

                $partsFrom['Bucket'],

                $partsFrom['Key'],

                $partsTo['Bucket'],

                $partsTo['Key'],

                isset($options['acl']) ? $options['acl'] : 'private',

                $options

            );

            // Delete the original object

            $this->getClient()->deleteObject([

                'Bucket' => $partsFrom['Bucket'],

                'Key'    => $partsFrom['Key']

            ] + $options);

            return true;

        });

    }

    public function stream_cast($cast_as)

    {

        return false;

    }

    public function stream_set_option($option, $arg1, $arg2)

    {

        return false;

    }

    public function stream_metadata($path, $option, $value)

    {

        return false;

    }

    public function stream_lock($operation)

    {

        trigger_error(

            'stream_lock() is not supported by the Amazon S3 stream wrapper',

            E_USER_WARNING

        );

        return false;

    }

    public function stream_truncate($new_size)

    {

        return false;

    }

    /**

     * Validates the provided stream arguments for fopen and returns an array

     * of errors.

     */

    private function validate($path, $mode)

    {

        $errors = [];

        if (!$this->getOption('Key')) {

            $errors[] = 'Cannot open a bucket. You must specify a path in the '

                . 'form of s3://bucket/key';

        }

        if (!in_array($mode, ['r', 'w', 'a', 'x'])) {

            $errors[] = "Mode not supported: {$mode}. "

                . "Use one 'r', 'w', 'a', or 'x'.";

        }

        if ($mode === 'x') {

            $method = self::$useV2Existence ? 'doesObjectExistV2' : 'doesObjectExist';

            if ($this->getClient()->$method(

                $this->getOption('Bucket'),

                $this->getOption('Key'),

                $this->getOptions(true)

            )) {

                $errors[] = "{$path} already exists on Amazon S3";

            }

        }

        return $errors;

    }

    /**

     * Get the stream context options available to the current stream

     *

     * @param bool $removeContextData Set to true to remove contextual kvp's

     *                                like 'client' from the result.

     *

     * @return array

     */

    private function getOptions($removeContextData = false)

    {

        // Context is not set when doing things like stat

        if ($this->context === null) {

            $options = [];

        } else {

            $options = stream_context_get_options($this->context);

            $options = isset($options[$this->protocol])

                ? $options[$this->protocol]

                : [];

        }

        $default = stream_context_get_options(stream_context_get_default());

        $default = isset($default[$this->protocol])

            ? $default[$this->protocol]

            : [];

        $result = $this->params + $options + $default;

        if ($removeContextData) {

            unset($result['client'], $result['seekable'], $result['cache']);

        }

        return $result;

    }

    /**

     * Get a specific stream context option

     *

     * @param string $name Name of the option to retrieve

     *

     * @return mixed|null

     */

    private function getOption($name)

    {

        $options = $this->getOptions();

        return isset($options[$name]) ? $options[$name] : null;

    }

    /**

     * Gets the client from the stream context

     *

     * @return S3ClientInterface

     * @throws \RuntimeException if no client has been configured

     */

    private function getClient()

    {

        if (!$client = $this->getOption('client')) {

            throw new \RuntimeException('No client in stream context');

        }

        return $client;

    }

    private function getBucketKey($path)

    {

        // Remove the protocol

        $parts = explode('://', $path);

        // Get the bucket, key

        $parts = explode('/', $parts[1], 2);

        return [

            'Bucket' => $parts[0],

            'Key'    => isset($parts[1]) ? $parts[1] : null

        ];

    }

    /**

     * Get the bucket and key from the passed path (e.g. s3://bucket/key)

     *

     * @param string $path Path passed to the stream wrapper

     *

     * @return array Hash of 'Bucket', 'Key', and custom params from the context

     */

    private function withPath($path)

    {

        $params = $this->getOptions(true);

        return $this->getBucketKey($path) + $params;

    }

    private function openReadStream()

    {

        $client = $this->getClient();

        $command = $client->getCommand('GetObject', $this->getOptions(true));

        $command['@http']['stream'] = true;

        $result = $client->execute($command);

        $this->size = $result['ContentLength'];

        $this->body = $result['Body'];

        // Wrap the body in a caching entity body if seeking is allowed

        if ($this->getOption('seekable') && !$this->body->isSeekable()) {

            $this->body = new CachingStream($this->body);

        }

        return true;

    }

    private function openWriteStream()

    {

        $this->body = new Stream(fopen('php://temp', 'r+'));

        return true;

    }

    private function openAppendStream()

    {

        try {

            // Get the body of the object and seek to the end of the stream

            $client = $this->getClient();

            $this->body = $client->getObject($this->getOptions(true))['Body'];

            $this->body->seek(0, SEEK_END);

            return true;

        } catch (S3Exception $e) {

            // The object does not exist, so use a simple write stream

            return $this->openWriteStream();

        }

    }

    /**

     * Trigger one or more errors

     *

     * @param string|array $errors Errors to trigger

     * @param mixed        $flags  If set to STREAM_URL_STAT_QUIET, then no

     *                             error or exception occurs

     *

     * @return bool Returns false

     * @throws \RuntimeException if throw_errors is true

     */

    private function triggerError($errors, $flags = null)

    {

        // This is triggered with things like file_exists()

        if ($flags & STREAM_URL_STAT_QUIET) {

            return $flags & STREAM_URL_STAT_LINK

                // This is triggered for things like is_link()

                ? $this->formatUrlStat(false)

                : false;

        }

        // This is triggered when doing things like lstat() or stat()

        trigger_error(implode("\n", (array) $errors), E_USER_WARNING);

        return false;

    }

    /**

     * Prepare a url_stat result array

     *

     * @param string|array $result Data to add

     *

     * @return array Returns the modified url_stat result

     */

    private function formatUrlStat($result = null)

    {

        $stat = $this->getStatTemplate();

        switch (gettype($result)) {

            case 'NULL':

            case 'string':

                // Directory with 0777 access - see "man 2 stat".

                $stat['mode'] = $stat[2] = 0040777;

                break;

            case 'array':

                // Regular file with 0777 access - see "man 2 stat".

                $stat['mode'] = $stat[2] = 0100777;

                // Pluck the content-length if available.

                if (isset($result['ContentLength'])) {

                    $stat['size'] = $stat[7] = $result['ContentLength'];

                } elseif (isset($result['Size'])) {

                    $stat['size'] = $stat[7] = $result['Size'];

                }

                if (isset($result['LastModified'])) {

                    // ListObjects or HeadObject result

                    $stat['mtime'] = $stat[9] = $stat['ctime'] = $stat[10]

                        = strtotime($result['LastModified']);

                }

        }

        return $stat;

    }

    /**

     * Creates a bucket for the given parameters.

     *

     * @param string $path   Stream wrapper path

     * @param array  $params A result of StreamWrapper::withPath()

     *

     * @return bool Returns true on success or false on failure

     */

    private function createBucket($path, array $params)

    {

        $method = self::$useV2Existence ? 'doesBucketExistV2' : 'doesBucketExist';

        if ($this->getClient()->$method($params['Bucket'])) {

            return $this->triggerError("Bucket already exists: {$path}");

        }

        unset($params['ACL']);

        return $this->boolCall(function () use ($params, $path) {

            $this->getClient()->createBucket($params);

            $this->clearCacheKey($path);

            return true;

        });

    }

    /**

     * Creates a pseudo-folder by creating an empty "/" suffixed key

     *

     * @param string $path   Stream wrapper path

     * @param array  $params A result of StreamWrapper::withPath()

     *

     * @return bool

     */

    private function createSubfolder($path, array $params)

    {

        // Ensure the path ends in "/" and the body is empty.

        $params['Key'] = rtrim($params['Key'], '/') . '/';

        $params['Body'] = '';

        // Fail if this pseudo directory key already exists

        $method = self::$useV2Existence ? 'doesObjectExistV2' : 'doesObjectExist';

        if ($this->getClient()->$method(

            $params['Bucket'],

            $params['Key']

        )) {

            return $this->triggerError("Subfolder already exists: {$path}");

        }

        return $this->boolCall(function () use ($params, $path) {

            $this->getClient()->putObject($params);

            $this->clearCacheKey($path);

            return true;

        });

    }

    /**

     * Deletes a nested subfolder if it is empty.

     *

     * @param string $path   Path that is being deleted (e.g., 's3://a/b/c')

     * @param array  $params A result of StreamWrapper::withPath()

     *

     * @return bool

     */

    private function deleteSubfolder($path, $params)

    {

        // Use a key that adds a trailing slash if needed.

        $prefix = rtrim($params['Key'], '/') . '/';

        $result = $this->getClient()->listObjects([

            'Bucket'  => $params['Bucket'],

            'Prefix'  => $prefix,

            'MaxKeys' => 1

        ]);

        // Check if the bucket contains keys other than the placeholder

        if ($contents = $result['Contents']) {

            return (count($contents) > 1 || $contents[0]['Key'] != $prefix)

                ? $this->triggerError('Subfolder is not empty')

                : $this->unlink(rtrim($path, '/') . '/');

        }

        return $result['CommonPrefixes']

            ? $this->triggerError('Subfolder contains nested folders')

            : true;

    }

    /**

     * Determine the most appropriate ACL based on a file mode.

     *

     * @param int $mode File mode

     *

     * @return string

     */

    private function determineAcl($mode)

    {

        switch (substr(decoct($mode), 0, 1)) {

            case '7': return 'public-read';

            case '6': return 'authenticated-read';

            default: return 'private';

        }

    }

    /**

     * Gets a URL stat template with default values

     *

     * @return array

     */

    private function getStatTemplate()

    {

        return [

            1  => 0,  'ino'     => 0,

            2  => 0,  'mode'    => 0,

            3  => 0,  'nlink'   => 0,

            4  => 0,  'uid'     => 0,

            5  => 0,  'gid'     => 0,

            6  => -1, 'rdev'    => -1,

            7  => 0,  'size'    => 0,

            8  => 0,  'atime'   => 0,

            9  => 0,  'mtime'   => 0,

            10 => 0,  'ctime'   => 0,

            11 => -1, 'blksize' => -1,

            12 => -1, 'blocks'  => -1,

        ];

    }

    /**

     * Invokes a callable and triggers an error if an exception occurs while

     * calling the function.

     *

     * @param callable $fn

     * @param int      $flags

     *

     * @return bool

     */

    private function boolCall(callable $fn, $flags = null)

    {

        try {

            return $fn();

        } catch (\Exception $e) {

            return $this->triggerError($e->getMessage(), $flags);

        }

    }

    /**

     * @return LruArrayCache

     */

    private function getCacheStorage()

    {

        if (!$this->cache) {

            $this->cache = $this->getOption('cache') ?: new LruArrayCache();

        }

        return $this->cache;

    }

    /**

     * Clears a specific stat cache value from the stat cache and LRU cache.

     *

     * @param string $key S3 path (s3://bucket/key).

     */

    private function clearCacheKey($key)

    {

        clearstatcache(true, $key);

        $this->getCacheStorage()->remove($key);

    }

    /**

     * Returns the size of the opened object body.

     *

     * @return int|null

     */

    private function getSize()

    {

        $size = $this->body->getSize();