Malin/WPS3Media
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add S3-compatible storage provider (MinIO, Ceph, R2, etc.)

Browse Source 
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
This commit is contained in:
Malin
2026-03-03 12:30:18 +01:00
commit 3248cbb029
2086 changed files with 359427 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
vendor/Aws3/Aws/Api/Parser/EventParsingIterator.php vendored Normal file
View File

@@ -0,0 +1,143 @@
<?php
namespace DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser;
use Iterator;
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Exception\EventStreamDataException;
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\Parser\Exception\ParserException;
use DeliciousBrains\WP_Offload_Media\Aws3\Aws\Api\StructureShape;
use DeliciousBrains\WP_Offload_Media\Aws3\Psr\Http\Message\StreamInterface;
/**
* @internal Implements a decoder for a binary encoded event stream that will
* decode, validate, and provide individual events from the stream.
*/
class EventParsingIterator implements Iterator
{
/** @var StreamInterface */
private $decodingIterator;
/** @var StructureShape */
private $shape;
/** @var AbstractParser */
private $parser;
public function __construct(StreamInterface $stream, StructureShape $shape, AbstractParser $parser)
{
$this->decodingIterator = $this->chooseDecodingIterator($stream);
$this->shape = $shape;
$this->parser = $parser;
}
/**
* This method choose a decoding iterator implementation based on if the stream
* is seekable or not.
*
* @param $stream
*
* @return Iterator
*/
private function chooseDecodingIterator($stream)
{
if ($stream->isSeekable()) {
return new DecodingEventStreamIterator($stream);
} else {
return new NonSeekableStreamDecodingEventStreamIterator($stream);
}
}
#[\ReturnTypeWillChange]
public function current()
{
return $this->parseEvent($this->decodingIterator->current());
}
#[\ReturnTypeWillChange]
public function key()
{
return $this->decodingIterator->key();
}
#[\ReturnTypeWillChange]
public function next()
{
$this->decodingIterator->next();
}
#[\ReturnTypeWillChange]
public function rewind()
{
$this->decodingIterator->rewind();
}
#[\ReturnTypeWillChange]
public function valid()
{
return $this->decodingIterator->valid();
}
private function parseEvent(array $event)
{
if (!empty($event['headers'][':message-type'])) {
if ($event['headers'][':message-type'] === 'error') {
return $this->parseError($event);
}
if ($event['headers'][':message-type'] !== 'event') {
throw new ParserException('Failed to parse unknown message type.');
}
}
$eventType = $event['headers'][':event-type'] ?? null;
if (empty($eventType)) {
throw new ParserException('Failed to parse without event type.');
}
$eventPayload = $event['payload'];
if ($eventType === 'initial-response') {
return $this->parseInitialResponseEvent($eventPayload);
}
$eventShape = $this->shape->getMember($eventType);
return [$eventType => \array_merge($this->parseEventHeaders($event['headers'], $eventShape), $this->parseEventPayload($eventPayload, $eventShape))];
}
/**
* @param $headers
* @param $eventShape
*
* @return array
*/
private function parseEventHeaders($headers, $eventShape) : array
{
$parsedHeaders = [];
foreach ($eventShape->getMembers() as $memberName => $memberProps) {
if (isset($memberProps['eventheader'])) {
$parsedHeaders[$memberName] = $headers[$memberName];
}
}
return $parsedHeaders;
}
/**
* @param $payload
* @param $eventShape
*
* @return array
*/
private function parseEventPayload($payload, $eventShape) : array
{
$parsedPayload = [];
foreach ($eventShape->getMembers() as $memberName => $memberProps) {
$memberShape = $eventShape->getMember($memberName);
if (isset($memberProps['eventpayload'])) {
if ($memberShape->getType() === 'blob') {
$parsedPayload[$memberName] = $payload;
} else {
$parsedPayload[$memberName] = $this->parser->parseMemberFromStream($payload, $memberShape, null);
}
break;
}
}
if (empty($parsedPayload) && !empty($payload->getContents())) {
/**
* If we did not find a member with an eventpayload trait, then we should deserialize the payload
* using the event's shape.
*/
$parsedPayload = $this->parser->parseMemberFromStream($payload, $eventShape, null);
}
return $parsedPayload;
}
private function parseError(array $event)
{
throw new EventStreamDataException($event['headers'][':error-code'], $event['headers'][':error-message']);
}
private function parseInitialResponseEvent($payload) : array
{
return ['initial-response' => \json_decode($payload, \true)];
}
}