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
236 lines
11 KiB
PHP
236 lines
11 KiB
PHP
<?php
|
|
|
|
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws;
|
|
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Exception\AwsException;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Retry\ConfigurationInterface;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Retry\QuotaManager;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Retry\RateLimiter;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Retry\RetryHelperTrait;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Exception\RequestException;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\GuzzleHttp\Promise;
|
|
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\RequestInterface;
|
|
/**
|
|
* Middleware that retries failures. V2 implementation that supports 'standard'
|
|
* and 'adaptive' modes.
|
|
*
|
|
* @internal
|
|
*/
|
|
class RetryMiddlewareV2
|
|
{
|
|
use RetryHelperTrait;
|
|
private static $standardThrottlingErrors = ['Throttling' => \true, 'ThrottlingException' => \true, 'ThrottledException' => \true, 'RequestThrottledException' => \true, 'TooManyRequestsException' => \true, 'ProvisionedThroughputExceededException' => \true, 'TransactionInProgressException' => \true, 'RequestLimitExceeded' => \true, 'BandwidthLimitExceeded' => \true, 'LimitExceededException' => \true, 'RequestThrottled' => \true, 'SlowDown' => \true, 'PriorRequestNotComplete' => \true, 'EC2ThrottledException' => \true];
|
|
private static $standardTransientErrors = ['RequestTimeout' => \true, 'RequestTimeoutException' => \true];
|
|
private static $standardTransientStatusCodes = [500 => \true, 502 => \true, 503 => \true, 504 => \true];
|
|
private $collectStats;
|
|
private $decider;
|
|
private $delayer;
|
|
private $maxAttempts;
|
|
private $maxBackoff;
|
|
private $mode;
|
|
private $nextHandler;
|
|
private $options;
|
|
private $quotaManager;
|
|
private $rateLimiter;
|
|
public static function wrap($config, $options)
|
|
{
|
|
return function (callable $handler) use($config, $options) {
|
|
return new static($config, $handler, $options);
|
|
};
|
|
}
|
|
public static function createDefaultDecider(QuotaManager $quotaManager, $maxAttempts = 3, $options = [])
|
|
{
|
|
$retryCurlErrors = [];
|
|
if (\extension_loaded('curl')) {
|
|
$retryCurlErrors[\CURLE_RECV_ERROR] = \true;
|
|
}
|
|
return function ($attempts, CommandInterface $command, $result) use($options, $quotaManager, $retryCurlErrors, $maxAttempts) {
|
|
// Release retry tokens back to quota on a successful result
|
|
$quotaManager->releaseToQuota($result);
|
|
// Allow command-level option to override this value
|
|
// # of attempts = # of retries + 1
|
|
$maxAttempts = null !== $command['@retries'] ? $command['@retries'] + 1 : $maxAttempts;
|
|
$isRetryable = self::isRetryable($result, $retryCurlErrors, $options);
|
|
if ($isRetryable) {
|
|
// Retrieve retry tokens and check if quota has been exceeded
|
|
if (!$quotaManager->hasRetryQuota($result)) {
|
|
return \false;
|
|
}
|
|
if ($attempts >= $maxAttempts) {
|
|
if (!empty($result) && $result instanceof AwsException) {
|
|
$result->setMaxRetriesExceeded();
|
|
}
|
|
return \false;
|
|
}
|
|
}
|
|
return $isRetryable;
|
|
};
|
|
}
|
|
public function __construct(ConfigurationInterface $config, callable $handler, $options = [])
|
|
{
|
|
$this->options = $options;
|
|
$this->maxAttempts = $config->getMaxAttempts();
|
|
$this->mode = $config->getMode();
|
|
$this->nextHandler = $handler;
|
|
$this->quotaManager = new QuotaManager();
|
|
$this->maxBackoff = isset($options['max_backoff']) ? $options['max_backoff'] : 20000;
|
|
$this->collectStats = isset($options['collect_stats']) ? (bool) $options['collect_stats'] : \false;
|
|
$this->decider = isset($options['decider']) ? $options['decider'] : self::createDefaultDecider($this->quotaManager, $this->maxAttempts, $options);
|
|
$this->delayer = isset($options['delayer']) ? $options['delayer'] : function ($attempts) {
|
|
return $this->exponentialDelayWithJitter($attempts);
|
|
};
|
|
if ($this->mode === 'adaptive') {
|
|
$this->rateLimiter = isset($options['rate_limiter']) ? $options['rate_limiter'] : new RateLimiter();
|
|
}
|
|
}
|
|
public function __invoke(CommandInterface $cmd, RequestInterface $req)
|
|
{
|
|
$decider = $this->decider;
|
|
$delayer = $this->delayer;
|
|
$handler = $this->nextHandler;
|
|
$attempts = 1;
|
|
$monitoringEvents = [];
|
|
$requestStats = [];
|
|
$req = $this->addRetryHeader($req, 0, 0);
|
|
$callback = function ($value) use($handler, $cmd, $req, $decider, $delayer, &$attempts, &$requestStats, &$monitoringEvents, &$callback) {
|
|
if ($this->mode === 'adaptive') {
|
|
$this->rateLimiter->updateSendingRate($this->isThrottlingError($value));
|
|
}
|
|
$this->updateHttpStats($value, $requestStats);
|
|
if ($value instanceof MonitoringEventsInterface) {
|
|
$reversedEvents = \array_reverse($monitoringEvents);
|
|
$monitoringEvents = \array_merge($monitoringEvents, $value->getMonitoringEvents());
|
|
foreach ($reversedEvents as $event) {
|
|
$value->prependMonitoringEvent($event);
|
|
}
|
|
}
|
|
if ($value instanceof \Exception || $value instanceof \Throwable) {
|
|
if (!$decider($attempts, $cmd, $value)) {
|
|
return Promise\Create::rejectionFor($this->bindStatsToReturn($value, $requestStats));
|
|
}
|
|
} elseif ($value instanceof ResultInterface && !$decider($attempts, $cmd, $value)) {
|
|
return $this->bindStatsToReturn($value, $requestStats);
|
|
}
|
|
$delayBy = $delayer($attempts++);
|
|
$cmd['@http']['delay'] = $delayBy;
|
|
if ($this->collectStats) {
|
|
$this->updateStats($attempts - 1, $delayBy, $requestStats);
|
|
}
|
|
// Update retry header with retry count and delayBy
|
|
$req = $this->addRetryHeader($req, $attempts - 1, $delayBy);
|
|
// Get token from rate limiter, which will sleep if necessary
|
|
if ($this->mode === 'adaptive') {
|
|
$this->rateLimiter->getSendToken();
|
|
}
|
|
return $handler($cmd, $req)->then($callback, $callback);
|
|
};
|
|
// Get token from rate limiter, which will sleep if necessary
|
|
if ($this->mode === 'adaptive') {
|
|
$this->rateLimiter->getSendToken();
|
|
}
|
|
return $handler($cmd, $req)->then($callback, $callback);
|
|
}
|
|
/**
|
|
* Amount of milliseconds to delay as a function of attempt number
|
|
*
|
|
* @param $attempts
|
|
* @return mixed
|
|
*/
|
|
public function exponentialDelayWithJitter($attempts)
|
|
{
|
|
$rand = \mt_rand() / \mt_getrandmax();
|
|
return \min(1000 * $rand * \pow(2, $attempts), $this->maxBackoff);
|
|
}
|
|
private static function isRetryable($result, $retryCurlErrors, $options = [])
|
|
{
|
|
$errorCodes = self::$standardThrottlingErrors + self::$standardTransientErrors;
|
|
if (!empty($options['transient_error_codes']) && \is_array($options['transient_error_codes'])) {
|
|
foreach ($options['transient_error_codes'] as $code) {
|
|
$errorCodes[$code] = \true;
|
|
}
|
|
}
|
|
if (!empty($options['throttling_error_codes']) && \is_array($options['throttling_error_codes'])) {
|
|
foreach ($options['throttling_error_codes'] as $code) {
|
|
$errorCodes[$code] = \true;
|
|
}
|
|
}
|
|
$statusCodes = self::$standardTransientStatusCodes;
|
|
if (!empty($options['status_codes']) && \is_array($options['status_codes'])) {
|
|
foreach ($options['status_codes'] as $code) {
|
|
$statusCodes[$code] = \true;
|
|
}
|
|
}
|
|
if (!empty($options['curl_errors']) && \is_array($options['curl_errors'])) {
|
|
foreach ($options['curl_errors'] as $code) {
|
|
$retryCurlErrors[$code] = \true;
|
|
}
|
|
}
|
|
if ($result instanceof \Exception || $result instanceof \Throwable) {
|
|
$isError = \true;
|
|
} else {
|
|
$isError = \false;
|
|
}
|
|
if (!$isError) {
|
|
if (!isset($result['@metadata']['statusCode'])) {
|
|
return \false;
|
|
}
|
|
return isset($statusCodes[$result['@metadata']['statusCode']]);
|
|
}
|
|
if (!$result instanceof AwsException) {
|
|
return \false;
|
|
}
|
|
if ($result->isConnectionError()) {
|
|
return \true;
|
|
}
|
|
if (!empty($errorCodes[$result->getAwsErrorCode()])) {
|
|
return \true;
|
|
}
|
|
if (!empty($statusCodes[$result->getStatusCode()])) {
|
|
return \true;
|
|
}
|
|
if (\count($retryCurlErrors) && ($previous = $result->getPrevious()) && $previous instanceof RequestException) {
|
|
if (\method_exists($previous, 'getHandlerContext')) {
|
|
$context = $previous->getHandlerContext();
|
|
return !empty($context['errno']) && isset($retryCurlErrors[$context['errno']]);
|
|
}
|
|
$message = $previous->getMessage();
|
|
foreach (\array_keys($retryCurlErrors) as $curlError) {
|
|
if (\strpos($message, 'cURL error ' . $curlError . ':') === 0) {
|
|
return \true;
|
|
}
|
|
}
|
|
}
|
|
// Check error shape for the retryable trait
|
|
if (!empty($errorShape = $result->getAwsErrorShape())) {
|
|
$definition = $errorShape->toArray();
|
|
if (!empty($definition['retryable'])) {
|
|
return \true;
|
|
}
|
|
}
|
|
return \false;
|
|
}
|
|
private function isThrottlingError($result)
|
|
{
|
|
if ($result instanceof AwsException) {
|
|
// Check pre-defined throttling errors
|
|
$throttlingErrors = self::$standardThrottlingErrors;
|
|
if (!empty($this->options['throttling_error_codes']) && \is_array($this->options['throttling_error_codes'])) {
|
|
foreach ($this->options['throttling_error_codes'] as $code) {
|
|
$throttlingErrors[$code] = \true;
|
|
}
|
|
}
|
|
if (!empty($result->getAwsErrorCode()) && !empty($throttlingErrors[$result->getAwsErrorCode()])) {
|
|
return \true;
|
|
}
|
|
// Check error shape for the throttling trait
|
|
if (!empty($errorShape = $result->getAwsErrorShape())) {
|
|
$definition = $errorShape->toArray();
|
|
if (!empty($definition['retryable']['throttling'])) {
|
|
return \true;
|
|
}
|
|
}
|
|
}
|
|
return \false;
|
|
}
|
|
}
|