vendor/league/flysystem-aws-s3-v3/AwsS3V3Adapter.php line 284

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace League\Flysystem\AwsS3V3;
  7. use Aws\Api\DateTimeResult;
  8. use Aws\S3\S3ClientInterface;
  9. use Generator;
  10. use League\Flysystem\Config;
  11. use League\Flysystem\DirectoryAttributes;
  12. use League\Flysystem\FileAttributes;
  13. use League\Flysystem\FilesystemAdapter;
  14. use League\Flysystem\FilesystemOperationFailed;
  15. use League\Flysystem\PathPrefixer;
  16. use League\Flysystem\StorageAttributes;
  17. use League\Flysystem\UnableToCheckFileExistence;
  18. use League\Flysystem\UnableToCopyFile;
  19. use League\Flysystem\UnableToDeleteFile;
  20. use League\Flysystem\UnableToMoveFile;
  21. use League\Flysystem\UnableToReadFile;
  22. use League\Flysystem\UnableToRetrieveMetadata;
  23. use League\Flysystem\UnableToSetVisibility;
  24. use League\Flysystem\UnableToWriteFile;
  25. use League\Flysystem\Visibility;
  26. use League\MimeTypeDetection\FinfoMimeTypeDetector;
  27. use League\MimeTypeDetection\MimeTypeDetector;
  28. use Psr\Http\Message\StreamInterface;
  29. use Throwable;
  31. class AwsS3V3Adapter implements FilesystemAdapter
  32. {
  33. /**
  34. * @var string[]
  35. */
  36. public const AVAILABLE_OPTIONS = [
  37. 'ACL',
  38. 'CacheControl',
  39. 'ContentDisposition',
  40. 'ContentEncoding',
  41. 'ContentLength',
  42. 'ContentType',
  43. 'Expires',
  44. 'GrantFullControl',
  45. 'GrantRead',
  46. 'GrantReadACP',
  47. 'GrantWriteACP',
  48. 'Metadata',
  49. 'MetadataDirective',
  50. 'RequestPayer',
  51. 'SSECustomerAlgorithm',
  52. 'SSECustomerKey',
  53. 'SSECustomerKeyMD5',
  54. 'SSEKMSKeyId',
  55. 'ServerSideEncryption',
  56. 'StorageClass',
  57. 'Tagging',
  58. 'WebsiteRedirectLocation',
  59. ];
  61. /**
  62. * @var string[]
  63. */
  64. private const EXTRA_METADATA_FIELDS = [
  65. 'Metadata',
  66. 'StorageClass',
  67. 'ETag',
  68. 'VersionId',
  69. ];
  71. /**
  72. * @var S3ClientInterface
  73. */
  74. private $client;
  76. /**
  77. * @var PathPrefixer
  78. */
  79. private $prefixer;
  81. /**
  82. * @var string
  83. */
  84. private $bucket;
  86. /**
  87. * @var VisibilityConverter
  88. */
  89. private $visibility;
  91. /**
  92. * @var MimeTypeDetector
  93. */
  94. private $mimeTypeDetector;
  96. /**
  97. * @var array
  98. */
  99. private $options;
  101. /**
  102. * @var bool
  103. */
  104. private $streamReads;
  106. public function __construct(
  107. S3ClientInterface $client,
  108. string $bucket,
  109. string $prefix = '',
  110. VisibilityConverter $visibility = null,
  111. MimeTypeDetector $mimeTypeDetector = null,
  112. array $options = [],
  113. bool $streamReads = true
  114. ) {
  115. $this->client = $client;
  116. $this->prefixer = new PathPrefixer($prefix);
  117. $this->bucket = $bucket;
  118. $this->visibility = $visibility ?: new PortableVisibilityConverter();
  119. $this->mimeTypeDetector = $mimeTypeDetector ?: new FinfoMimeTypeDetector();
  120. $this->options = $options;
  121. $this->streamReads = $streamReads;
  122. }
  124. public function fileExists(string $path): bool
  125. {
  126. try {
  127. return $this->client->doesObjectExist($this->bucket, $this->prefixer->prefixPath($path), $this->options);
  128. } catch (Throwable $exception) {
  129. throw UnableToCheckFileExistence::forLocation($path, $exception);
  130. }
  131. }
  133. public function write(string $path, string $contents, Config $config): void
  134. {
  135. $this->upload($path, $contents, $config);
  136. }
  138. /**
  139. * @param string $path
  140. * @param string|resource $body
  141. * @param Config $config
  142. */
  143. private function upload(string $path, $body, Config $config): void
  144. {
  145. $key = $this->prefixer->prefixPath($path);
  146. $options = $this->createOptionsFromConfig($config);
  147. $acl = $options['ACL'] ?? $this->determineAcl($config);
  148. $shouldDetermineMimetype = $body !== '' && ! array_key_exists('ContentType', $options);
  150. if ($shouldDetermineMimetype && $mimeType = $this->mimeTypeDetector->detectMimeType($key, $body)) {
  151. $options['ContentType'] = $mimeType;
  152. }
  154. try {
  155. $this->client->upload($this->bucket, $key, $body, $acl, ['params' => $options]);
  156. } catch (Throwable $exception) {
  157. throw UnableToWriteFile::atLocation($path, '', $exception);
  158. }
  159. }
  161. private function determineAcl(Config $config): string
  162. {
  163. $visibility = (string) $config->get(Config::OPTION_VISIBILITY, Visibility::PRIVATE);
  165. return $this->visibility->visibilityToAcl($visibility);
  166. }
  168. private function createOptionsFromConfig(Config $config): array
  169. {
  170. $options = [];
  172. if ($mimetype = $config->get('mimetype')) {
  173. $options['ContentType'] = $mimetype;
  174. }
  176. foreach (static::AVAILABLE_OPTIONS as $option) {
  177. $value = $config->get($option, '__NOT_SET__');
  179. if ($value !== '__NOT_SET__') {
  180. $options[$option] = $value;
  181. }
  182. }
  184. return $options + $this->options;
  185. }
  187. public function writeStream(string $path, $contents, Config $config): void
  188. {
  189. $this->upload($path, $contents, $config);
  190. }
  192. public function read(string $path): string
  193. {
  194. $body = $this->readObject($path, false);
  196. return (string) $body->getContents();
  197. }
  199. public function readStream(string $path)
  200. {
  201. /** @var resource $resource */
  202. $resource = $this->readObject($path, true)->detach();
  204. return $resource;
  205. }
  207. public function delete(string $path): void
  208. {
  209. $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
  210. $command = $this->client->getCommand('DeleteObject', $arguments);
  212. try {
  213. $this->client->execute($command);
  214. } catch (Throwable $exception) {
  215. throw UnableToDeleteFile::atLocation($path, '', $exception);
  216. }
  217. }
  219. public function deleteDirectory(string $path): void
  220. {
  221. $prefix = $this->prefixer->prefixPath($path);
  222. $prefix = ltrim(rtrim($prefix, '/') . '/', '/');
  223. $this->client->deleteMatchingObjects($this->bucket, $prefix);
  224. }
  226. public function createDirectory(string $path, Config $config): void
  227. {
  228. $config = $config->withDefaults(['visibility' => $this->visibility->defaultForDirectories()]);
  229. $this->upload(rtrim($path, '/') . '/', '', $config);
  230. }
  232. public function setVisibility(string $path, string $visibility): void
  233. {
  234. $arguments = [
  235. 'Bucket' => $this->bucket,
  236. 'Key' => $this->prefixer->prefixPath($path),
  237. 'ACL' => $this->visibility->visibilityToAcl($visibility),
  238. ];
  239. $command = $this->client->getCommand('PutObjectAcl', $arguments);
  241. try {
  242. $this->client->execute($command);
  243. } catch (Throwable $exception) {
  244. throw UnableToSetVisibility::atLocation($path, '', $exception);
  245. }
  246. }
  248. public function visibility(string $path): FileAttributes
  249. {
  250. $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
  251. $command = $this->client->getCommand('GetObjectAcl', $arguments);
  253. try {
  254. $result = $this->client->execute($command);
  255. } catch (Throwable $exception) {
  256. throw UnableToRetrieveMetadata::visibility($path, '', $exception);
  257. }
  259. $visibility = $this->visibility->aclToVisibility((array) $result->get('Grants'));
  261. return new FileAttributes($path, null, $visibility);
  262. }
  264. private function fetchFileMetadata(string $path, string $type): FileAttributes
  265. {
  266. $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
  267. $command = $this->client->getCommand('HeadObject', $arguments);
  269. try {
  270. $result = $this->client->execute($command);
  271. } catch (Throwable $exception) {
  272. throw UnableToRetrieveMetadata::create($path, $type, '', $exception);
  273. }
  275. $attributes = $this->mapS3ObjectMetadata($result->toArray(), $path);
  277. if ( ! $attributes instanceof FileAttributes) {
  278. throw UnableToRetrieveMetadata::create($path, $type, '');
  279. }
  281. return $attributes;
  282. }
  284. private function mapS3ObjectMetadata(array $metadata, string $path = null): StorageAttributes
  285. {
  286. if ($path === null) {
  287. $path = $this->prefixer->stripPrefix($metadata['Key'] ?? $metadata['Prefix']);
  288. }
  290. if (substr($path, -1) === '/') {
  291. return new DirectoryAttributes(rtrim($path, '/'));
  292. }
  294. $mimetype = $metadata['ContentType'] ?? null;
  295. $fileSize = $metadata['ContentLength'] ?? $metadata['Size'] ?? null;
  296. $fileSize = $fileSize === null ? null : (int) $fileSize;
  297. $dateTime = $metadata['LastModified'] ?? null;
  298. $lastModified = $dateTime instanceof DateTimeResult ? $dateTime->getTimeStamp() : null;
  300. return new FileAttributes(
  301. $path,
  302. $fileSize,
  303. null,
  304. $lastModified,
  305. $mimetype,
  306. $this->extractExtraMetadata($metadata)
  307. );
  308. }
  310. private function extractExtraMetadata(array $metadata): array
  311. {
  312. $extracted = [];
  314. foreach (static::EXTRA_METADATA_FIELDS as $field) {
  315. if (isset($metadata[$field]) && $metadata[$field] !== '') {
  316. $extracted[$field] = $metadata[$field];
  317. }
  318. }
  320. return $extracted;
  321. }
  323. public function mimeType(string $path): FileAttributes
  324. {
  325. $attributes = $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_MIME_TYPE);
  327. if ($attributes->mimeType() === null) {
  328. throw UnableToRetrieveMetadata::mimeType($path);
  329. }
  331. return $attributes;
  332. }
  334. public function lastModified(string $path): FileAttributes
  335. {
  336. $attributes = $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_LAST_MODIFIED);
  338. if ($attributes->lastModified() === null) {
  339. throw UnableToRetrieveMetadata::lastModified($path);
  340. }
  342. return $attributes;
  343. }
  345. public function fileSize(string $path): FileAttributes
  346. {
  347. $attributes = $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_FILE_SIZE);
  349. if ($attributes->fileSize() === null) {
  350. throw UnableToRetrieveMetadata::fileSize($path);
  351. }
  353. return $attributes;
  354. }
  356. public function listContents(string $path, bool $deep): iterable
  357. {
  358. $prefix = trim($this->prefixer->prefixPath($path), '/');
  359. $prefix = empty($prefix) ? '' : $prefix . '/';
  360. $options = ['Bucket' => $this->bucket, 'Prefix' => $prefix];
  362. if ($deep === false) {
  363. $options['Delimiter'] = '/';
  364. }
  366. $listing = $this->retrievePaginatedListing($options);
  368. foreach ($listing as $item) {
  369. yield $this->mapS3ObjectMetadata($item);
  370. }
  371. }
  373. private function retrievePaginatedListing(array $options): Generator
  374. {
  375. $resultPaginator = $this->client->getPaginator('ListObjects', $options + $this->options);
  377. foreach ($resultPaginator as $result) {
  378. yield from ($result->get('CommonPrefixes') ?: []);
  379. yield from ($result->get('Contents') ?: []);
  380. }
  381. }
  383. public function move(string $source, string $destination, Config $config): void
  384. {
  385. try {
  386. $this->copy($source, $destination, $config);
  387. $this->delete($source);
  388. } catch (FilesystemOperationFailed $exception) {
  389. throw UnableToMoveFile::fromLocationTo($source, $destination, $exception);
  390. }
  391. }
  393. public function copy(string $source, string $destination, Config $config): void
  394. {
  395. try {
  396. /** @var string $visibility */
  397. $visibility = $config->get(Config::OPTION_VISIBILITY) ?: $this->visibility($source)->visibility();
  398. } catch (Throwable $exception) {
  399. throw UnableToCopyFile::fromLocationTo(
  400. $source,
  401. $destination,
  402. $exception
  403. );
  404. }
  406. try {
  407. $this->client->copy(
  408. $this->bucket,
  409. $this->prefixer->prefixPath($source),
  410. $this->bucket,
  411. $this->prefixer->prefixPath($destination),
  412. $this->visibility->visibilityToAcl($visibility),
  413. $this->createOptionsFromConfig($config)
  414. );
  415. } catch (Throwable $exception) {
  416. throw UnableToCopyFile::fromLocationTo($source, $destination, $exception);
  417. }
  418. }
  420. private function readObject(string $path, bool $wantsStream): StreamInterface
  421. {
  422. $options = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
  424. if ($wantsStream && $this->streamReads && ! isset($this->options['@http']['stream'])) {
  425. $options['@http']['stream'] = true;
  426. }
  428. $command = $this->client->getCommand('GetObject', $options + $this->options);
  430. try {
  431. return $this->client->execute($command)->get('Body');
  432. } catch (Throwable $exception) {
  433. throw UnableToReadFile::fromLocation($path, '', $exception);
  434. }
  435. }
  436. }