Malin
3248cbb029
Adds a new 'S3-Compatible Storage' provider that works with any
S3-API-compatible object storage service, including MinIO, Ceph,
Cloudflare R2, Backblaze B2, and others.
Changes:
- New provider class: classes/providers/storage/s3-compatible-provider.php
- Provider key: s3compatible
- Reads user-configured endpoint URL from settings
- Uses path-style URL access (required by most S3-compatible services)
- Supports credentials via AS3CF_S3COMPAT_ACCESS_KEY_ID /
AS3CF_S3COMPAT_SECRET_ACCESS_KEY wp-config.php constants
- Disables AWS-specific features (Block Public Access, Object Ownership)
- New provider SVG icons (s3compatible.svg, -link.svg, -round.svg)
- Registered provider in main plugin class with endpoint setting support
- Updated StorageProviderSubPage to show endpoint URL input for S3-compatible
- Built pro settings bundle with rollup (Svelte 4.2.19)
- Added package.json and updated rollup.config.mjs for pro-only builds
219 lines
10 KiB
PHP
219 lines
10 KiB
PHP
<?php
|
|
|
|
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\S3;
|
|
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Arn\ArnParser;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Arn\ObjectLambdaAccessPointArn;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\ClientResolver;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\CommandInterface;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Endpoint\EndpointProvider;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Endpoint\PartitionEndpointProvider;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Exception\InvalidArgumentException;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Psr7\Uri;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\RequestInterface;
|
|
/**
|
|
* Used to update the URL used for S3 requests to support:
|
|
* S3 Accelerate, S3 DualStack or Both. It will build to
|
|
* host style paths unless specified, including for S3
|
|
* DualStack.
|
|
*
|
|
* IMPORTANT: this middleware must be added after the "build" step.
|
|
*
|
|
* @internal
|
|
*/
|
|
class S3EndpointMiddleware
|
|
{
|
|
private static $exclusions = ['CreateBucket' => \true, 'DeleteBucket' => \true, 'ListBuckets' => \true];
|
|
const NO_PATTERN = 0;
|
|
const DUALSTACK = 1;
|
|
const ACCELERATE = 2;
|
|
const ACCELERATE_DUALSTACK = 3;
|
|
const PATH_STYLE = 4;
|
|
const HOST_STYLE = 5;
|
|
/** @var bool */
|
|
private $accelerateByDefault;
|
|
/** @var bool */
|
|
private $dualStackByDefault;
|
|
/** @var bool */
|
|
private $pathStyleByDefault;
|
|
/** @var string */
|
|
private $region;
|
|
/** @var callable */
|
|
private $endpointProvider;
|
|
/** @var callable */
|
|
private $nextHandler;
|
|
/** @var string */
|
|
private $endpoint;
|
|
/**
|
|
* Create a middleware wrapper function
|
|
*
|
|
* @param string $region
|
|
* @param EndpointProvider $endpointProvider
|
|
* @param array $options
|
|
*
|
|
* @return callable
|
|
*/
|
|
public static function wrap($region, $endpointProvider, array $options)
|
|
{
|
|
return function (callable $handler) use($region, $endpointProvider, $options) {
|
|
return new self($handler, $region, $options, $endpointProvider);
|
|
};
|
|
}
|
|
public function __construct(callable $nextHandler, $region, array $options, $endpointProvider = null)
|
|
{
|
|
$this->pathStyleByDefault = isset($options['path_style']) ? (bool) $options['path_style'] : \false;
|
|
$this->dualStackByDefault = isset($options['dual_stack']) ? (bool) $options['dual_stack'] : \false;
|
|
$this->accelerateByDefault = isset($options['accelerate']) ? (bool) $options['accelerate'] : \false;
|
|
$this->region = (string) $region;
|
|
$this->endpoint = isset($options['endpoint']) ? $options['endpoint'] : "";
|
|
$this->endpointProvider = \is_null($endpointProvider) ? PartitionEndpointProvider::defaultProvider() : $endpointProvider;
|
|
$this->nextHandler = $nextHandler;
|
|
}
|
|
public function __invoke(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
if (!empty($this->endpoint)) {
|
|
$request = $this->applyEndpoint($command, $request);
|
|
} else {
|
|
switch ($this->endpointPatternDecider($command, $request)) {
|
|
case self::HOST_STYLE:
|
|
$request = $this->applyHostStyleEndpoint($command, $request);
|
|
break;
|
|
case self::NO_PATTERN:
|
|
break;
|
|
case self::PATH_STYLE:
|
|
$request = $this->applyPathStyleEndpointCustomizations($command, $request);
|
|
break;
|
|
case self::DUALSTACK:
|
|
$request = $this->applyDualStackEndpoint($command, $request);
|
|
break;
|
|
case self::ACCELERATE:
|
|
$request = $this->applyAccelerateEndpoint($command, $request, 's3-accelerate');
|
|
break;
|
|
case self::ACCELERATE_DUALSTACK:
|
|
$request = $this->applyAccelerateEndpoint($command, $request, 's3-accelerate.dualstack');
|
|
break;
|
|
}
|
|
}
|
|
$nextHandler = $this->nextHandler;
|
|
return $nextHandler($command, $request);
|
|
}
|
|
private static function isRequestHostStyleCompatible(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
return S3Client::isBucketDnsCompatible($command['Bucket']) && ($request->getUri()->getScheme() === 'http' || \strpos($command['Bucket'], '.') === \false) && \filter_var($request->getUri()->getHost(), \FILTER_VALIDATE_IP) === \false;
|
|
}
|
|
private function endpointPatternDecider(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
$accelerate = isset($command['@use_accelerate_endpoint']) ? $command['@use_accelerate_endpoint'] : $this->accelerateByDefault;
|
|
$dualStack = isset($command['@use_dual_stack_endpoint']) ? $command['@use_dual_stack_endpoint'] : $this->dualStackByDefault;
|
|
$pathStyle = isset($command['@use_path_style_endpoint']) ? $command['@use_path_style_endpoint'] : $this->pathStyleByDefault;
|
|
if ($accelerate && $dualStack) {
|
|
// When try to enable both for operations excluded from s3-accelerate,
|
|
// only dualstack endpoints will be enabled.
|
|
return $this->canAccelerate($command) ? self::ACCELERATE_DUALSTACK : self::DUALSTACK;
|
|
}
|
|
if ($accelerate && $this->canAccelerate($command)) {
|
|
return self::ACCELERATE;
|
|
}
|
|
if ($dualStack) {
|
|
return self::DUALSTACK;
|
|
}
|
|
if (!$pathStyle && self::isRequestHostStyleCompatible($command, $request)) {
|
|
return self::HOST_STYLE;
|
|
}
|
|
return self::PATH_STYLE;
|
|
}
|
|
private function canAccelerate(CommandInterface $command)
|
|
{
|
|
return empty(self::$exclusions[$command->getName()]) && S3Client::isBucketDnsCompatible($command['Bucket']);
|
|
}
|
|
private function getBucketStyleHost(CommandInterface $command, $host)
|
|
{
|
|
// For operations on the base host (e.g. ListBuckets)
|
|
if (!isset($command['Bucket'])) {
|
|
return $host;
|
|
}
|
|
return "{$command['Bucket']}.{$host}";
|
|
}
|
|
private function applyHostStyleEndpoint(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
$uri = $request->getUri();
|
|
$request = $request->withUri($uri->withHost($this->getBucketStyleHost($command, $uri->getHost()))->withPath($this->getBucketlessPath($uri->getPath(), $command)));
|
|
return $request;
|
|
}
|
|
private function applyPathStyleEndpointCustomizations(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
if ($command->getName() == 'WriteGetObjectResponse') {
|
|
$dnsSuffix = $this->endpointProvider->getPartition($this->region, 's3')->getDnsSuffix();
|
|
$fips = \DeliciousBrains\WP_Offload_Media\Aws3\Aws\is_fips_pseudo_region($this->region) ? "-fips" : "";
|
|
$region = \DeliciousBrains\WP_Offload_Media\Aws3\Aws\strip_fips_pseudo_regions($this->region);
|
|
$host = "{$command['RequestRoute']}.s3-object-lambda{$fips}.{$region}.{$dnsSuffix}";
|
|
$uri = $request->getUri();
|
|
$request = $request->withUri($uri->withHost($host)->withPath($this->getBucketlessPath($uri->getPath(), $command)));
|
|
}
|
|
return $request;
|
|
}
|
|
private function applyDualStackEndpoint(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
$request = $request->withUri($request->getUri()->withHost($this->getDualStackHost()));
|
|
if (empty($command['@use_path_style_endpoint']) && !$this->pathStyleByDefault && self::isRequestHostStyleCompatible($command, $request)) {
|
|
$request = $this->applyHostStyleEndpoint($command, $request);
|
|
}
|
|
return $request;
|
|
}
|
|
private function getDualStackHost()
|
|
{
|
|
$dnsSuffix = $this->endpointProvider->getPartition($this->region, 's3')->getDnsSuffix();
|
|
return "s3.dualstack.{$this->region}.{$dnsSuffix}";
|
|
}
|
|
private function applyAccelerateEndpoint(CommandInterface $command, RequestInterface $request, $pattern)
|
|
{
|
|
$request = $request->withUri($request->getUri()->withHost($this->getAccelerateHost($command, $pattern))->withPath($this->getBucketlessPath($request->getUri()->getPath(), $command)));
|
|
return $request;
|
|
}
|
|
private function getAccelerateHost(CommandInterface $command, $pattern)
|
|
{
|
|
$dnsSuffix = $this->endpointProvider->getPartition($this->region, 's3')->getDnsSuffix();
|
|
return "{$command['Bucket']}.{$pattern}.{$dnsSuffix}";
|
|
}
|
|
private function getBucketlessPath($path, CommandInterface $command)
|
|
{
|
|
$pattern = '/^\\/' . \preg_quote($command['Bucket'], '/') . '/';
|
|
$path = \preg_replace($pattern, '', $path) ?: '/';
|
|
if (\substr($path, 0, 1) !== '/') {
|
|
$path = '/' . $path;
|
|
}
|
|
return $path;
|
|
}
|
|
private function applyEndpoint(CommandInterface $command, RequestInterface $request)
|
|
{
|
|
$dualStack = isset($command['@use_dual_stack_endpoint']) ? $command['@use_dual_stack_endpoint'] : $this->dualStackByDefault;
|
|
if (ArnParser::isArn($command['Bucket'])) {
|
|
$arn = ArnParser::parse($command['Bucket']);
|
|
$outpost = $arn->getService() == 's3-outposts';
|
|
if ($outpost && $dualStack) {
|
|
throw new InvalidArgumentException("Outposts + dualstack is not supported");
|
|
}
|
|
if ($arn instanceof ObjectLambdaAccessPointArn) {
|
|
return $request;
|
|
}
|
|
}
|
|
if ($dualStack) {
|
|
throw new InvalidArgumentException("Custom Endpoint + Dualstack not supported");
|
|
}
|
|
if ($command->getName() == 'WriteGetObjectResponse') {
|
|
$host = "{$command['RequestRoute']}.{$this->endpoint}";
|
|
$uri = $request->getUri();
|
|
return $request = $request->withUri($uri->withHost($host)->withPath($this->getBucketlessPath($uri->getPath(), $command)));
|
|
}
|
|
$host = $this->pathStyleByDefault ? $this->endpoint : $this->getBucketStyleHost($command, $this->endpoint);
|
|
$uri = $request->getUri();
|
|
$scheme = $uri->getScheme();
|
|
if (empty($scheme)) {
|
|
$request = $request->withUri($uri->withHost($host));
|
|
} else {
|
|
$request = $request->withUri($uri);
|
|
}
|
|
return $request;
|
|
}
|
|
}
|