AwsS3Provider::getFilesAlreadyOnBucket() - Code Metrics - Inspection of "Calculate files differences now with ETag too" - publiux/laravelcdn - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#51)

by Raimondas

created 2019-02-07 15:25 UTC

AwsS3Provider::getFilesAlreadyOnBucket() A

↳ Parent: AwsS3Provider

Complexity

Conditions	5
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	37
rs	9.0168
c	0
b	0
f	0
cc	5
nc	3
nop	1

<?php

namespace Publiux\laravelcdn\Providers;

use Aws\S3\BatchDelete;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Illuminate\Support\Collection;
use Publiux\laravelcdn\Contracts\CdnHelperInterface;
use Publiux\laravelcdn\Providers\Contracts\ProviderInterface;
use Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface;
use Symfony\Component\Console\Output\ConsoleOutput;

/**
 * Class AwsS3Provider
 * Amazon (AWS) S3.
 *
 *
 * @category Driver
 *
 * @property string  $provider_url
 * @property string  $threshold
 * @property string  $version
 * @property string  $region
 * @property string  $credential_key
 * @property string  $credential_secret
 * @property string  $buckets
 * @property string  $acl
 * @property string  $cloudfront
 * @property string  $cloudfront_url
 * @property string $http
 *
 * @author   Mahmoud Zalt <[email protected]>
 */
class AwsS3Provider extends Provider implements ProviderInterface
{
    /**
     * All the configurations needed by this class with the
     * optional configurations default values.
     *
     * @var array
     */
    protected $default = [
        'url' => null,
        'threshold' => 10,
        'providers' => [
            'aws' => [
                's3' => [
                    'version' => null,
                    'region' => null,
                    'endpoint' => null,
                    'buckets' => null,
                    'upload_folder' => '',
                    'http' => null,
                    'acl' => 'public-read',
                    'cloudfront' => [
                        'use' => false,
                        'cdn_url' => null,
                    ],
                ],
            ],
        ],
    ];

    /**
     * Required configurations (must exist in the config file).
     *
     * @var array
     */
    protected $rules = ['version', 'region', 'key', 'secret', 'buckets', 'url'];

    /**
     * this array holds the parsed configuration to be used across the class.
     *
     * @var Array
     */
    protected $supplier;

    /**
     * @var Instance of Aws\S3\S3Client
     */
    protected $s3_client;

    /**
     * @var Instance of Guzzle\Batch\BatchBuilder
     */
    protected $batch;

    /**
     * @var \Publiux\laravelcdn\Contracts\CdnHelperInterface
     */
    protected $cdn_helper;

    /**
     * @var \Publiux\laravelcdn\Validators\Contracts\ConfigurationsInterface
     */
    protected $configurations;

    /**
     * @var \Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface
     */
    protected $provider_validator;

    /**
     * @param \Symfony\Component\Console\Output\ConsoleOutput $console
     * @param \Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface $provider_validator
     * @param \Publiux\laravelcdn\Contracts\CdnHelperInterface                    $cdn_helper
     */
    public function __construct(
        ConsoleOutput $console,
        ProviderValidatorInterface $provider_validator,
        CdnHelperInterface $cdn_helper
    ) {
        $this->console = $console;

        $this->provider_validator = $provider_validator;
        $this->cdn_helper = $cdn_helper;
    }

    /**
     * Read the configuration and prepare an array with the relevant configurations
     * for the (AWS S3) provider. and return itself.
     *
     * @param $configurations
     *
     * @return $this
     */
    public function init($configurations)
    {
        // merge the received config array with the default configurations array to
        // fill missed keys with null or default values.
        $this->default = array_replace_recursive($this->default, $configurations);

        $supplier = [
            'provider_url' => $this->default['url'],
            'threshold' => $this->default['threshold'],
            'version' => $this->default['providers']['aws']['s3']['version'],
            'region' => $this->default['providers']['aws']['s3']['region'],
            'endpoint' => $this->default['providers']['aws']['s3']['endpoint'],
            'buckets' => $this->default['providers']['aws']['s3']['buckets'],
            'acl' => $this->default['providers']['aws']['s3']['acl'],
            'cloudfront' => $this->default['providers']['aws']['s3']['cloudfront']['use'],
            'cloudfront_url' => $this->default['providers']['aws']['s3']['cloudfront']['cdn_url'],
            'http' => $this->default['providers']['aws']['s3']['http'],
            'upload_folder' => $this->default['providers']['aws']['s3']['upload_folder']
        ];

        // check if any required configuration is missed
        $this->provider_validator->validate($supplier, $this->rules);

        $this->supplier = $supplier;

        return $this;
    }

    /**
     * Upload assets.
     *
     * @param $assets
     *
     * @return bool
     */
    public function upload($assets)
    {
        // connect before uploading
        $connected = $this->connect();

        if (!$connected) {
            return false;
        }

        // user terminal message
        $this->console->writeln('<fg=yellow>Comparing local files and bucket...</fg=yellow>');

        $assets = $this->getFilesToUpload($assets);

        // upload each asset file to the CDN
        if (count($assets) > 0) {
            $this->console->writeln('<fg=yellow>Upload in progress......</fg=yellow>');
            foreach ($assets as $file) {
                try {
                    $this->console->writeln('<fg=cyan>'.'Uploading file path: '.$file->getRealpath().'</fg=cyan>');
                    $command = $this->s3_client->getCommand('putObject', [

                        // the bucket name
                        'Bucket' => $this->getBucket(),
                        // the path of the file on the server (CDN)
                        'Key' => $this->supplier['upload_folder'] . str_replace('\\', '/', $file->getPathName()),
                        // the path of the path locally
                        'Body' => fopen($file->getRealPath(), 'r'),
                        // the permission of the file

                        'ACL' => $this->acl,
                        'CacheControl' => $this->default['providers']['aws']['s3']['cache-control'],
                        'Metadata' => $this->default['providers']['aws']['s3']['metadata'],
                        'Expires' => $this->default['providers']['aws']['s3']['expires'],
                    ]);
//                var_dump(get_class($command));exit();


                    $this->s3_client->execute($command);
                } catch (S3Exception $e) {
                    $this->console->writeln('<fg=red>Upload error: '.$e->getMessage().'</fg=red>');
                    return false;
                }
            }

            // user terminal message
            $this->console->writeln('<fg=green>Upload completed successfully.</fg=green>');
        } else {
            // user terminal message
            $this->console->writeln('<fg=yellow>No new files to upload.</fg=yellow>');
        }

        return true;
    }

    /**
     * Create an S3 client instance
     * (Note: it will read the credentials form the .env file).
     *
     * @return bool
     */
    public function connect()
    {
        try {
            // Instantiate an S3 client
            $this->setS3Client(new S3Client([
                        'version' => $this->supplier['version'],
                        'region' => $this->supplier['region'],
                        'endpoint' => $this->supplier['endpoint'],
                        'http' => $this->supplier['http']
                    ]
                )
            );
        } catch (\Exception $e) {
            $this->console->writeln('<fg=red>Connection error: '.$e->getMessage().'</fg=red>');
            return false;
        }

        return true;
    }

    /**
     * @param $s3_client
     */
    public function setS3Client($s3_client)
    {
        $this->s3_client = $s3_client;
    }

    /**
     * Get files to upload
     *
     * @param $assets
     * @return mixed
     */
    private function getFilesToUpload($assets)
    {
        $filesOnAWS = new Collection([]);

        $files = $this->s3_client->listObjects([
            'Bucket' => $this->getBucket(),
        ]);

        if (!$files['Contents']) {
            //no files on bucket. lets upload everything found.
            return $assets;
        }

        foreach ($files['Contents'] as $file) {
            $a = [
                'Key' => $file['Key'],
                'Hash' => trim($file['ETag'], '"'),
                "LastModified" => $file['LastModified']->getTimestamp(),
                'Size' => $file['Size']
            ];
            $filesOnAWS->put($file['Key'], $a);
        }

        $assets = $assets->reject(function ($item) use ($filesOnAWS) {
            $key = str_replace('\\', '/', $item->getPathName());
            if (!$filesOnAWS->has($key)) {
                return false;
            }

            $fileOnAWS = $filesOnAWS->get($key);

            if (
                ($item->getMTime() === $fileOnAWS['LastModified']) &&
                ($item->getSize() === $fileOnAWS['Size'])
            ) {
                return false;
            }

            return !$this->calculateEtag($item->getPathName(), -8, $fileOnAWS['Hash']);
        });

        return $assets;
    }

    /**
     * @return array
     */
    public function getBucket()
    {
        // this step is very important, "always assign returned array from
        // magical function to a local variable if you need to modify it's
        // state or apply any php function on it." because the returned is
        // a copy of the original variable. this prevent this error:
        // Indirect modification of overloaded property
        // Vinelab\Cdn\Providers\AwsS3Provider::$buckets has no effect
        $bucket = $this->buckets;

        return rtrim(key($bucket), '/');
    }

    /**
     * Empty bucket.
     *
     * @return bool
     */
    public function emptyBucket()
    {

        // connect before uploading
        $connected = $this->connect();

        if (!$connected) {
            return false;
        }

        // user terminal message
        $this->console->writeln('<fg=yellow>Emptying in progress...</fg=yellow>');

        try {

            // Get the contents of the bucket for information purposes
            $contents = $this->s3_client->listObjects([
                'Bucket' => $this->getBucket(),
                'Key' => '',
            ]);

            // Check if the bucket is already empty
            if (!$contents['Contents']) {
                $this->console->writeln('<fg=green>The bucket '.$this->getBucket().' is already empty.</fg=green>');

                return true;
            }

            // Empty out the bucket
            $empty = BatchDelete::fromListObjects($this->s3_client, [
                'Bucket' => $this->getBucket(),
                'Prefix' => null,
            ]);

            $empty->delete();
        } catch (S3Exception $e) {
            $this->console->writeln('<fg=red>Deletion error: '.$e->getMessage().'</fg=red>');
            return false;
        }

        $this->console->writeln('<fg=green>The bucket '.$this->getBucket().' is now empty.</fg=green>');

        return true;
    }

    /**
     * This function will be called from the CdnFacade class when
     * someone use this {{ Cdn::asset('') }} facade helper.
     *
     * @param $path
     *
     * @return string
     */
    public function urlGenerator($path)
    {
        if ($this->getCloudFront() === true) {
            $url = $this->cdn_helper->parseUrl($this->getCloudFrontUrl());

            return $url['scheme'] . '://' . $url['host'] . '/' . $path;
        }

        $url = $this->cdn_helper->parseUrl($this->getUrl());

        $bucket = $this->getBucket();
        $bucket = (!empty($bucket)) ? $bucket.'.' : '';

        return $url['scheme'] . '://' . $bucket . $url['host'] . '/' . $path;
    }

    /**
     * @return string
     */
    public function getCloudFront()
    {
        if (!is_bool($cloudfront = $this->cloudfront)) {
            return false;
        }

        return $cloudfront;
    }

    /**
     * @return string
     */
    public function getCloudFrontUrl()
    {
        return rtrim($this->cloudfront_url, '/').'/';
    }

    /**
     * @return string
     */
    public function getUrl()
    {
        return rtrim($this->provider_url, '/') . '/';
    }
    
    /**
     * Calculate Amazon AWS ETag used on the S3 service
     *
     * @see https://stackoverflow.com/a/36072294/1762839
     * @author TheStoryCoder (https://stackoverflow.com/users/2404541/thestorycoder)
     *
     * @param string $filename path to file to check
     * @param int $chunksize chunk size in Megabytes
     * @param bool|string $expected verify calculated etag against this specified
     *                              etag and return true or false instead if you make
     *                              chunksize negative (eg. -8 instead of 8) the function
     *                              will guess the chunksize by checking all possible sizes
     *                              given the number of parts mentioned in $expected
     *
     * @return bool|string          ETag (string) or boolean true|false if $expected is set
     */
    protected function calculateEtag($filename, $chunksize, $expected = false) {
        if ($chunksize < 0) {
            $do_guess = true;
            $chunksize = 0 - $chunksize;
        } else {
            $do_guess = false;
        }

        $chunkbytes = $chunksize*1024*1024;
        $filesize = filesize($filename);
        if ($filesize < $chunkbytes && (!$expected || !preg_match("/^\\w{32}-\\w+$/", $expected))) {
            $return = md5_file($filename);
            if ($expected) {
                $expected = strtolower($expected);
                return ($expected === $return ? true : false);
            } else {
                return $return;
            }
        } else {
            $md5s = array();
            $handle = fopen($filename, 'rb');
            if ($handle === false) {
                return false;
            }
            while (!feof($handle)) {
                $buffer = fread($handle, $chunkbytes);
                $md5s[] = md5($buffer);
                unset($buffer);
            }
            fclose($handle);

            $concat = '';
            foreach ($md5s as $indx => $md5) {
                $concat .= hex2bin($md5);
            }
            $return = md5($concat) .'-'. count($md5s);
            if ($expected) {
                $expected = strtolower($expected);
                $matches = ($expected === $return ? true : false);
                if ($matches || $do_guess == false || strlen($expected) == 32) {

                    return $matches;
                } else {
                    // Guess the chunk size
                    preg_match("/-(\\d+)$/", $expected, $match);
                    $parts = $match[1];
                    $min_chunk = ceil($filesize / $parts /1024/1024);
                    $max_chunk =  floor($filesize / ($parts-1) /1024/1024);
                    $found_match = false;
                    for ($i = $min_chunk; $i <= $max_chunk; $i++) {
                        if ($this->calculateEtag($filename, $i) === $expected) {
                            $found_match = true;
                            break;
                        }
                    }
                    return $found_match;
                }
            } else {
                return $return;
            }
        }
    }


    /**
     * @param $attr
     *
     * @return Mix | null
     */
    public function __get($attr)
    {
        return isset($this->supplier[$attr]) ? $this->supplier[$attr] : null;
    }
}


1			<?php
2
3			namespace Publiux\laravelcdn\Providers;
4
5			use Aws\S3\BatchDelete;
6			use Aws\S3\Exception\S3Exception;
7			use Aws\S3\S3Client;
8			use Illuminate\Support\Collection;
9			use Publiux\laravelcdn\Contracts\CdnHelperInterface;
10			use Publiux\laravelcdn\Providers\Contracts\ProviderInterface;
11			use Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface;
12			use Symfony\Component\Console\Output\ConsoleOutput;
13
14			/**
15			* Class AwsS3Provider
16			* Amazon (AWS) S3.
17			*
18			*
19			* @category Driver
20			*
21			* @property string $provider_url
22			* @property string $threshold
23			* @property string $version
24			* @property string $region
25			* @property string $credential_key
26			* @property string $credential_secret
27			* @property string $buckets
28			* @property string $acl
29			* @property string $cloudfront
30			* @property string $cloudfront_url
31			* @property string $http
32			*
33			* @author Mahmoud Zalt <[email protected]>
34			*/
35			class AwsS3Provider extends Provider implements ProviderInterface
36			{
37			/**
38			* All the configurations needed by this class with the
39			* optional configurations default values.
40			*
41			* @var array
42			*/
43			protected $default = [
44			'url' => null,
45			'threshold' => 10,
46			'providers' => [
47			'aws' => [
48			's3' => [
49			'version' => null,
50			'region' => null,
51			'endpoint' => null,
52			'buckets' => null,
53			'upload_folder' => '',
54			'http' => null,
55			'acl' => 'public-read',
56			'cloudfront' => [
57			'use' => false,
58			'cdn_url' => null,
59			],
60			],
61			],
62			],
63			];
64
65			/**
66			* Required configurations (must exist in the config file).
67			*
68			* @var array
69			*/
70			protected $rules = ['version', 'region', 'key', 'secret', 'buckets', 'url'];
71
72			/**
73			* this array holds the parsed configuration to be used across the class.
74			*
75			* @var Array
76			*/
77			protected $supplier;
78
79			/**
80			* @var Instance of Aws\S3\S3Client
81			*/
82			protected $s3_client;
83
84			/**
85			* @var Instance of Guzzle\Batch\BatchBuilder
86			*/
87			protected $batch;
88
89			/**
90			* @var \Publiux\laravelcdn\Contracts\CdnHelperInterface
91			*/
92			protected $cdn_helper;
93
94			/**
95			* @var \Publiux\laravelcdn\Validators\Contracts\ConfigurationsInterface
96			*/
97			protected $configurations;
98
99			/**
100			* @var \Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface
101			*/
102			protected $provider_validator;
103
104			/**
105			* @param \Symfony\Component\Console\Output\ConsoleOutput $console
106			* @param \Publiux\laravelcdn\Validators\Contracts\ProviderValidatorInterface $provider_validator
107			* @param \Publiux\laravelcdn\Contracts\CdnHelperInterface $cdn_helper
108			*/
109			public function __construct(
110			ConsoleOutput $console,
111			ProviderValidatorInterface $provider_validator,
112			CdnHelperInterface $cdn_helper
113			) {
114			$this->console = $console;
			0 ignored issues – show Documentation Bug introduced 2016-01-17 19:08 UTC by Report Bug Copy Issue Report It seems like `$console` of type `object<Symfony\Component...e\Output\ConsoleOutput>` is incompatible with the declared type `object<Publiux\laravelcdn\Providers\Instance>` of property `$console`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
115			$this->provider_validator = $provider_validator;
116			$this->cdn_helper = $cdn_helper;
117			}
118
119			/**
120			* Read the configuration and prepare an array with the relevant configurations
121			* for the (AWS S3) provider. and return itself.
122			*
123			* @param $configurations
124			*
125			* @return $this
126			*/
127			public function init($configurations)
128			{
129			// merge the received config array with the default configurations array to
130			// fill missed keys with null or default values.
131			$this->default = array_replace_recursive($this->default, $configurations);
132
133			$supplier = [
134			'provider_url' => $this->default['url'],
135			'threshold' => $this->default['threshold'],
136			'version' => $this->default['providers']['aws']['s3']['version'],
137			'region' => $this->default['providers']['aws']['s3']['region'],
138			'endpoint' => $this->default['providers']['aws']['s3']['endpoint'],
139			'buckets' => $this->default['providers']['aws']['s3']['buckets'],
140			'acl' => $this->default['providers']['aws']['s3']['acl'],
141			'cloudfront' => $this->default['providers']['aws']['s3']['cloudfront']['use'],
142			'cloudfront_url' => $this->default['providers']['aws']['s3']['cloudfront']['cdn_url'],
143			'http' => $this->default['providers']['aws']['s3']['http'],
144			'upload_folder' => $this->default['providers']['aws']['s3']['upload_folder']
145			];
146
147			// check if any required configuration is missed
148			$this->provider_validator->validate($supplier, $this->rules);
149
150			$this->supplier = $supplier;
151
152			return $this;
153			}
154
155			/**
156			* Upload assets.
157			*
158			* @param $assets
159			*
160			* @return bool
161			*/
162			public function upload($assets)
163			{
164			// connect before uploading
165			$connected = $this->connect();
166
167			if (!$connected) {
168			return false;
169			}
170
171			// user terminal message
172			$this->console->writeln('<fg=yellow>Comparing local files and bucket...</fg=yellow>');
173
174			$assets = $this->getFilesToUpload($assets);
175
176			// upload each asset file to the CDN
177			if (count($assets) > 0) {
178			$this->console->writeln('<fg=yellow>Upload in progress......</fg=yellow>');
179			foreach ($assets as $file) {
180			try {
181			$this->console->writeln('<fg=cyan>'.'Uploading file path: '.$file->getRealpath().'</fg=cyan>');
182			$command = $this->s3_client->getCommand('putObject', [
183
184			// the bucket name
185			'Bucket' => $this->getBucket(),
186			// the path of the file on the server (CDN)
187			'Key' => $this->supplier['upload_folder'] . str_replace('\\', '/', $file->getPathName()),
188			// the path of the path locally
189			'Body' => fopen($file->getRealPath(), 'r'),
190			// the permission of the file
191
192			'ACL' => $this->acl,
193			'CacheControl' => $this->default['providers']['aws']['s3']['cache-control'],
194			'Metadata' => $this->default['providers']['aws']['s3']['metadata'],
195			'Expires' => $this->default['providers']['aws']['s3']['expires'],
196			]);
197			// var_dump(get_class($command));exit();
198
199
200			$this->s3_client->execute($command);
201			} catch (S3Exception $e) {
202			$this->console->writeln('<fg=red>Upload error: '.$e->getMessage().'</fg=red>');
203			return false;
204			}
205			}
206
207			// user terminal message
208			$this->console->writeln('<fg=green>Upload completed successfully.</fg=green>');
209			} else {
210			// user terminal message
211			$this->console->writeln('<fg=yellow>No new files to upload.</fg=yellow>');
212			}
213
214			return true;
215			}
216
217			/**
218			* Create an S3 client instance
219			* (Note: it will read the credentials form the .env file).
220			*
221			* @return bool
222			*/
223			public function connect()
224			{
225			try {
226			// Instantiate an S3 client
227			$this->setS3Client(new S3Client([
228			'version' => $this->supplier['version'],
229			'region' => $this->supplier['region'],
230			'endpoint' => $this->supplier['endpoint'],
231			'http' => $this->supplier['http']
232			]
233			)
234			);
235			} catch (\Exception $e) {
236			$this->console->writeln('<fg=red>Connection error: '.$e->getMessage().'</fg=red>');
237			return false;
238			}
239
240			return true;
241			}
242
243			/**
244			* @param $s3_client
245			*/
246			public function setS3Client($s3_client)
247			{
248			$this->s3_client = $s3_client;
249			}
250
251			/**
252			* Get files to upload
253			*
254			* @param $assets
255			* @return mixed
256			*/
257			private function getFilesToUpload($assets)
258			{
259			$filesOnAWS = new Collection([]);
260
261			$files = $this->s3_client->listObjects([
262			'Bucket' => $this->getBucket(),
263			]);
264
265			if (!$files['Contents']) {
266			//no files on bucket. lets upload everything found.
267			return $assets;
268			}
269
270			foreach ($files['Contents'] as $file) {
271			$a = [
272			'Key' => $file['Key'],
273			'Hash' => trim($file['ETag'], '"'),
274			"LastModified" => $file['LastModified']->getTimestamp(),
275			'Size' => $file['Size']
276			];
277			$filesOnAWS->put($file['Key'], $a);
278			}
279
280			$assets = $assets->reject(function ($item) use ($filesOnAWS) {
281			$key = str_replace('\\', '/', $item->getPathName());
282			if (!$filesOnAWS->has($key)) {
283			return false;
284			}
285
286			$fileOnAWS = $filesOnAWS->get($key);
287
288			if (
289			($item->getMTime() === $fileOnAWS['LastModified']) &&
290			($item->getSize() === $fileOnAWS['Size'])
291			) {
292			return false;
293			}
294
295			return !$this->calculateEtag($item->getPathName(), -8, $fileOnAWS['Hash']);
296			});
297
298			return $assets;
299			}
300
301			/**
302			* @return array
303			*/
304			public function getBucket()
305			{
306			// this step is very important, "always assign returned array from
307			// magical function to a local variable if you need to modify it's
308			// state or apply any php function on it." because the returned is
309			// a copy of the original variable. this prevent this error:
310			// Indirect modification of overloaded property
311			// Vinelab\Cdn\Providers\AwsS3Provider::$buckets has no effect
312			$bucket = $this->buckets;
313
314			return rtrim(key($bucket), '/');
315			}
316
317			/**
318			* Empty bucket.
319			*
320			* @return bool
321			*/
322			public function emptyBucket()
323			{
324
325			// connect before uploading
326			$connected = $this->connect();
327
328			if (!$connected) {
329			return false;
330			}
331
332			// user terminal message
333			$this->console->writeln('<fg=yellow>Emptying in progress...</fg=yellow>');
334
335			try {
336
337			// Get the contents of the bucket for information purposes
338			$contents = $this->s3_client->listObjects([
339			'Bucket' => $this->getBucket(),
340			'Key' => '',
341			]);
342
343			// Check if the bucket is already empty
344			if (!$contents['Contents']) {
345			$this->console->writeln('<fg=green>The bucket '.$this->getBucket().' is already empty.</fg=green>');
346
347			return true;
348			}
349
350			// Empty out the bucket
351			$empty = BatchDelete::fromListObjects($this->s3_client, [
352			'Bucket' => $this->getBucket(),
353			'Prefix' => null,
354			]);
355
356			$empty->delete();
357			} catch (S3Exception $e) {
358			$this->console->writeln('<fg=red>Deletion error: '.$e->getMessage().'</fg=red>');
359			return false;
360			}
361
362			$this->console->writeln('<fg=green>The bucket '.$this->getBucket().' is now empty.</fg=green>');
363
364			return true;
365			}
366
367			/**
368			* This function will be called from the CdnFacade class when
369			* someone use this {{ Cdn::asset('') }} facade helper.
370			*
371			* @param $path
372			*
373			* @return string
374			*/
375			public function urlGenerator($path)
376			{
377			if ($this->getCloudFront() === true) {
378			$url = $this->cdn_helper->parseUrl($this->getCloudFrontUrl());
379
380			return $url['scheme'] . '://' . $url['host'] . '/' . $path;
381			}
382
383			$url = $this->cdn_helper->parseUrl($this->getUrl());
384
385			$bucket = $this->getBucket();
386			$bucket = (!empty($bucket)) ? $bucket.'.' : '';
387
388			return $url['scheme'] . '://' . $bucket . $url['host'] . '/' . $path;
389			}
390
391			/**
392			* @return string
393			*/
394			public function getCloudFront()
395			{
396			if (!is_bool($cloudfront = $this->cloudfront)) {
397			return false;
398			}
399
400			return $cloudfront;
401			}
402
403			/**
404			* @return string
405			*/
406			public function getCloudFrontUrl()
407			{
408			return rtrim($this->cloudfront_url, '/').'/';
409			}
410
411			/**
412			* @return string
413			*/
414			public function getUrl()
415			{
416			return rtrim($this->provider_url, '/') . '/';
417			}
418
419			/**
420			* Calculate Amazon AWS ETag used on the S3 service
421			*
422			* @see https://stackoverflow.com/a/36072294/1762839
423			* @author TheStoryCoder (https://stackoverflow.com/users/2404541/thestorycoder)
424			*
425			* @param string $filename path to file to check
426			* @param int $chunksize chunk size in Megabytes
427			* @param bool\|string $expected verify calculated etag against this specified
428			* etag and return true or false instead if you make
429			* chunksize negative (eg. -8 instead of 8) the function
430			* will guess the chunksize by checking all possible sizes
431			* given the number of parts mentioned in $expected
432			*
433			* @return bool\|string ETag (string) or boolean true\|false if $expected is set
434			*/
435			protected function calculateEtag($filename, $chunksize, $expected = false) {
436			if ($chunksize < 0) {
437			$do_guess = true;
438			$chunksize = 0 - $chunksize;
439			} else {
440			$do_guess = false;
441			}
442
443			$chunkbytes = $chunksize10241024;
444			$filesize = filesize($filename);
445			if ($filesize < $chunkbytes && (!$expected \|\| !preg_match("/^\\w{32}-\\w+$/", $expected))) {
446			$return = md5_file($filename);
447			if ($expected) {
448			$expected = strtolower($expected);
449			return ($expected === $return ? true : false);
450			} else {
451			return $return;
452			}
453			} else {
454			$md5s = array();
455			$handle = fopen($filename, 'rb');
456			if ($handle === false) {
457			return false;
458			}
459			while (!feof($handle)) {
460			$buffer = fread($handle, $chunkbytes);
461			$md5s[] = md5($buffer);
462			unset($buffer);
463			}
464			fclose($handle);
465
466			$concat = '';
467			foreach ($md5s as $indx => $md5) {
468			$concat .= hex2bin($md5);
469			}
470			$return = md5($concat) .'-'. count($md5s);
471			if ($expected) {
472			$expected = strtolower($expected);
473			$matches = ($expected === $return ? true : false);
474			if ($matches \|\| $do_guess == false \|\| strlen($expected) == 32) {
			0 ignored issues – show Coding Style Best Practice introduced 2019-02-07 15:27 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
475			return $matches;
476			} else {
477			// Guess the chunk size
478			preg_match("/-(\\d+)$/", $expected, $match);
479			$parts = $match[1];
480			$min_chunk = ceil($filesize / $parts /1024/1024);
481			$max_chunk = floor($filesize / ($parts-1) /1024/1024);
482			$found_match = false;
483			for ($i = $min_chunk; $i <= $max_chunk; $i++) {
484			if ($this->calculateEtag($filename, $i) === $expected) {
485			$found_match = true;
486			break;
487			}
488			}
489			return $found_match;
490			}
491			} else {
492			return $return;
493			}
494			}
495			}
496
497
498			/**
499			* @param $attr
500			*
501			* @return Mix \| null
502			*/
503			public function __get($attr)
504			{
505			return isset($this->supplier[$attr]) ? $this->supplier[$attr] : null;
506			}
507			}
508

publiux / laravelcdn

Pull Request — master (#51)

AwsS3Provider::getFilesAlreadyOnBucket() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like