kawaiipunk/laipower
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

installed plugin Infinite Uploads version 2.0.8

Browse Source
This commit is contained in:
KawaiiPunk
2025-05-02 12:03:21 +00:00
committed by Gitium
parent 7ca941b591
commit 8fefb19ab4
1179 changed files with 99739 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/AbstractMonitoringMiddleware.php vendored Normal file
View File

@ -0,0 +1,226 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
use UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface;
use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
/**
* @internal
*/
abstract class AbstractMonitoringMiddleware implements \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\MonitoringMiddlewareInterface
{
private static $socket;
private $nextHandler;
private $options;
protected $credentialProvider;
protected $region;
protected $service;
protected static function getAwsExceptionHeader(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e, $headerName)
{
$response = $e->getResponse();
if ($response !== null) {
$header = $response->getHeader($headerName);
if (!empty($header[0])) {
return $header[0];
}
}
return null;
}
protected static function getResultHeader(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result, $headerName)
{
if (isset($result['@metadata']['headers'][$headerName])) {
return $result['@metadata']['headers'][$headerName];
}
return null;
}
protected static function getExceptionHeader(\Exception $e, $headerName)
{
if ($e instanceof ResponseContainerInterface) {
$response = $e->getResponse();
if ($response instanceof ResponseInterface) {
$header = $response->getHeader($headerName);
if (!empty($header[0])) {
return $header[0];
}
}
}
return null;
}
/**
* Constructor stores the passed in handler and options.
*
* @param callable $handler
* @param callable $credentialProvider
* @param $options
* @param $region
* @param $service
*/
public function __construct(callable $handler, callable $credentialProvider, $options, $region, $service)
{
$this->nextHandler = $handler;
$this->credentialProvider = $credentialProvider;
$this->options = $options;
$this->region = $region;
$this->service = $service;
}
/**
* Standard invoke pattern for middleware execution to be implemented by
* child classes.
*
* @param CommandInterface $cmd
* @param RequestInterface $request
* @return Promise\PromiseInterface
*/
public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
{
$handler = $this->nextHandler;
$eventData = null;
$enabled = $this->isEnabled();
if ($enabled) {
$cmd['@http']['collect_stats'] = true;
$eventData = $this->populateRequestEventData($cmd, $request, $this->getNewEvent($cmd, $request));
}
$g = function ($value) use($eventData, $enabled) {
if ($enabled) {
$eventData = $this->populateResultEventData($value, $eventData);
$this->sendEventData($eventData);
if ($value instanceof MonitoringEventsInterface) {
$value->appendMonitoringEvent($eventData);
}
}
if ($value instanceof \Exception || $value instanceof \Throwable) {
return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\rejection_for($value);
}
return $value;
};
return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($handler($cmd, $request))->then($g, $g);
}
private function getClientId()
{
return $this->unwrappedOptions()->getClientId();
}
private function getNewEvent(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
{
$event = ['Api' => $cmd->getName(), 'ClientId' => $this->getClientId(), 'Region' => $this->getRegion(), 'Service' => $this->getService(), 'Timestamp' => (int) floor(microtime(true) * 1000), 'UserAgent' => substr($request->getHeaderLine('User-Agent') . ' ' . \UglyRobot\Infinite_Uploads\Aws\default_user_agent(), 0, 256), 'Version' => 1];
return $event;
}
private function getHost()
{
return $this->unwrappedOptions()->getHost();
}
private function getPort()
{
return $this->unwrappedOptions()->getPort();
}
private function getRegion()
{
return $this->region;
}
private function getService()
{
return $this->service;
}
/**
* Returns enabled flag from options, unwrapping options if necessary.
*
* @return bool
*/
private function isEnabled()
{
return $this->unwrappedOptions()->isEnabled();
}
/**
* Returns $eventData array with information from the request and command.
*
* @param CommandInterface $cmd
* @param RequestInterface $request
* @param array $event
* @return array
*/
protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
{
$dataFormat = static::getRequestData($request);
foreach ($dataFormat as $eventKey => $value) {
if ($value !== null) {
$event[$eventKey] = $value;
}
}
return $event;
}
/**
* Returns $eventData array with information from the response, including
* the calculation for attempt latency.
*
* @param ResultInterface|\Exception $result
* @param array $event
* @return array
*/
protected function populateResultEventData($result, array $event)
{
$dataFormat = static::getResponseData($result);
foreach ($dataFormat as $eventKey => $value) {
if ($value !== null) {
$event[$eventKey] = $value;
}
}
return $event;
}
/**
* Creates a UDP socket resource and stores it with the class, or retrieves
* it if already instantiated and connected. Handles error-checking and
* re-connecting if necessary. If $forceNewConnection is set to true, a new
* socket will be created.
*
* @param bool $forceNewConnection
* @return Resource
*/
private function prepareSocket($forceNewConnection = false)
{
if (!is_resource(self::$socket) || $forceNewConnection || socket_last_error(self::$socket)) {
self::$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
socket_clear_error(self::$socket);
socket_connect(self::$socket, $this->getHost(), $this->getPort());
}
return self::$socket;
}
/**
* Sends formatted monitoring event data via the UDP socket connection to
* the CSM agent endpoint.
*
* @param array $eventData
* @return int
*/
private function sendEventData(array $eventData)
{
$socket = $this->prepareSocket();
$datagram = json_encode($eventData);
$result = socket_write($socket, $datagram, strlen($datagram));
if ($result === false) {
$this->prepareSocket(true);
}
return $result;
}
/**
* Unwraps options, if needed, and returns them.
*
* @return ConfigurationInterface
*/
private function unwrappedOptions()
{
if (!$this->options instanceof ConfigurationInterface) {
try {
$this->options = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::unwrap($this->options);
} catch (\Exception $e) {
// Errors unwrapping CSM config defaults to disabling it
$this->options = new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration(false, \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::DEFAULT_HOST, \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::DEFAULT_PORT);
}
}
return $this->options;
}
}

181
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ApiCallAttemptMonitoringMiddleware.php vendored Normal file
View File

@ -0,0 +1,181 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
use UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface;
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
use UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface;
use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
/**
* @internal
*/
class ApiCallAttemptMonitoringMiddleware extends \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\AbstractMonitoringMiddleware
{
/**
* Standard middleware wrapper function with CSM options passed in.
*
* @param callable $credentialProvider
* @param mixed $options
* @param string $region
* @param string $service
* @return callable
*/
public static function wrap(callable $credentialProvider, $options, $region, $service)
{
return function (callable $handler) use($credentialProvider, $options, $region, $service) {
return new static($handler, $credentialProvider, $options, $region, $service);
};
}
/**
* {@inheritdoc}
*/
public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
{
return ['Fqdn' => $request->getUri()->getHost()];
}
/**
* {@inheritdoc}
*/
public static function getResponseData($klass)
{
if ($klass instanceof ResultInterface) {
return ['AttemptLatency' => self::getResultAttemptLatency($klass), 'DestinationIp' => self::getResultDestinationIp($klass), 'DnsLatency' => self::getResultDnsLatency($klass), 'HttpStatusCode' => self::getResultHttpStatusCode($klass), 'XAmzId2' => self::getResultHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getResultHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getResultHeader($klass, 'x-amzn-RequestId')];
}
if ($klass instanceof AwsException) {
return ['AttemptLatency' => self::getAwsExceptionAttemptLatency($klass), 'AwsException' => substr(self::getAwsExceptionErrorCode($klass), 0, 128), 'AwsExceptionMessage' => substr(self::getAwsExceptionMessage($klass), 0, 512), 'DestinationIp' => self::getAwsExceptionDestinationIp($klass), 'DnsLatency' => self::getAwsExceptionDnsLatency($klass), 'HttpStatusCode' => self::getAwsExceptionHttpStatusCode($klass), 'XAmzId2' => self::getAwsExceptionHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getAwsExceptionHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getAwsExceptionHeader($klass, 'x-amzn-RequestId')];
}
if ($klass instanceof \Exception) {
return ['HttpStatusCode' => self::getExceptionHttpStatusCode($klass), 'SdkException' => substr(self::getExceptionCode($klass), 0, 128), 'SdkExceptionMessage' => substr(self::getExceptionMessage($klass), 0, 512), 'XAmzId2' => self::getExceptionHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getExceptionHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getExceptionHeader($klass, 'x-amzn-RequestId')];
}
throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface, AwsException or Exception.');
}
private static function getResultAttemptLatency(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
{
if (isset($result['@metadata']['transferStats']['http'])) {
$attempt = end($result['@metadata']['transferStats']['http']);
if (isset($attempt['total_time'])) {
return (int) floor($attempt['total_time'] * 1000);
}
}
return null;
}
private static function getResultDestinationIp(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
{
if (isset($result['@metadata']['transferStats']['http'])) {
$attempt = end($result['@metadata']['transferStats']['http']);
if (isset($attempt['primary_ip'])) {
return $attempt['primary_ip'];
}
}
return null;
}
private static function getResultDnsLatency(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
{
if (isset($result['@metadata']['transferStats']['http'])) {
$attempt = end($result['@metadata']['transferStats']['http']);
if (isset($attempt['namelookup_time'])) {
return (int) floor($attempt['namelookup_time'] * 1000);
}
}
return null;
}
private static function getResultHttpStatusCode(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
{
return $result['@metadata']['statusCode'];
}
private static function getAwsExceptionAttemptLatency(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
$attempt = $e->getTransferInfo();
if (isset($attempt['total_time'])) {
return (int) floor($attempt['total_time'] * 1000);
}
return null;
}
private static function getAwsExceptionErrorCode(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
return $e->getAwsErrorCode();
}
private static function getAwsExceptionMessage(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
return $e->getAwsErrorMessage();
}
private static function getAwsExceptionDestinationIp(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
$attempt = $e->getTransferInfo();
if (isset($attempt['primary_ip'])) {
return $attempt['primary_ip'];
}
return null;
}
private static function getAwsExceptionDnsLatency(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
$attempt = $e->getTransferInfo();
if (isset($attempt['namelookup_time'])) {
return (int) floor($attempt['namelookup_time'] * 1000);
}
return null;
}
private static function getAwsExceptionHttpStatusCode(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
{
$response = $e->getResponse();
if ($response !== null) {
return $response->getStatusCode();
}
return null;
}
private static function getExceptionHttpStatusCode(\Exception $e)
{
if ($e instanceof ResponseContainerInterface) {
$response = $e->getResponse();
if ($response instanceof ResponseInterface) {
return $response->getStatusCode();
}
}
return null;
}
private static function getExceptionCode(\Exception $e)
{
if (!$e instanceof AwsException) {
return get_class($e);
}
return null;
}
private static function getExceptionMessage(\Exception $e)
{
if (!$e instanceof AwsException) {
return $e->getMessage();
}
return null;
}
/**
* {@inheritdoc}
*/
protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
{
$event = parent::populateRequestEventData($cmd, $request, $event);
$event['Type'] = 'ApiCallAttempt';
return $event;
}
/**
* {@inheritdoc}
*/
protected function populateResultEventData($result, array $event)
{
$event = parent::populateResultEventData($result, $event);
$provider = $this->credentialProvider;
/** @var CredentialsInterface $credentials */
$credentials = $provider()->wait();
$event['AccessKey'] = $credentials->getAccessKeyId();
$sessionToken = $credentials->getSecurityToken();
if ($sessionToken !== null) {
$event['SessionToken'] = $sessionToken;
}
if (empty($event['AttemptLatency'])) {
$event['AttemptLatency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
}
return $event;
}
}

126
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ApiCallMonitoringMiddleware.php vendored Normal file
View File

@ -0,0 +1,126 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
/**
* @internal
*/
class ApiCallMonitoringMiddleware extends \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\AbstractMonitoringMiddleware
{
/**
* Api Call Attempt event keys for each Api Call event key
*
* @var array
*/
private static $eventKeys = ['FinalAwsException' => 'AwsException', 'FinalAwsExceptionMessage' => 'AwsExceptionMessage', 'FinalSdkException' => 'SdkException', 'FinalSdkExceptionMessage' => 'SdkExceptionMessage', 'FinalHttpStatusCode' => 'HttpStatusCode'];
/**
* Standard middleware wrapper function with CSM options passed in.
*
* @param callable $credentialProvider
* @param mixed $options
* @param string $region
* @param string $service
* @return callable
*/
public static function wrap(callable $credentialProvider, $options, $region, $service)
{
return function (callable $handler) use($credentialProvider, $options, $region, $service) {
return new static($handler, $credentialProvider, $options, $region, $service);
};
}
/**
* {@inheritdoc}
*/
public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
{
return [];
}
/**
* {@inheritdoc}
*/
public static function getResponseData($klass)
{
if ($klass instanceof ResultInterface) {
$data = ['AttemptCount' => self::getResultAttemptCount($klass), 'MaxRetriesExceeded' => 0];
} elseif ($klass instanceof \Exception) {
$data = ['AttemptCount' => self::getExceptionAttemptCount($klass), 'MaxRetriesExceeded' => self::getMaxRetriesExceeded($klass)];
} else {
throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface or Exception.');
}
return $data + self::getFinalAttemptData($klass);
}
private static function getResultAttemptCount(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
{
if (isset($result['@metadata']['transferStats']['http'])) {
return count($result['@metadata']['transferStats']['http']);
}
return 1;
}
private static function getExceptionAttemptCount(\Exception $e)
{
$attemptCount = 0;
if ($e instanceof MonitoringEventsInterface) {
foreach ($e->getMonitoringEvents() as $event) {
if (isset($event['Type']) && $event['Type'] === 'ApiCallAttempt') {
$attemptCount++;
}
}
}
return $attemptCount;
}
private static function getFinalAttemptData($klass)
{
$data = [];
if ($klass instanceof MonitoringEventsInterface) {
$finalAttempt = self::getFinalAttempt($klass->getMonitoringEvents());
if (!empty($finalAttempt)) {
foreach (self::$eventKeys as $callKey => $attemptKey) {
if (isset($finalAttempt[$attemptKey])) {
$data[$callKey] = $finalAttempt[$attemptKey];
}
}
}
}
return $data;
}
private static function getFinalAttempt(array $events)
{
for (end($events); key($events) !== null; prev($events)) {
$current = current($events);
if (isset($current['Type']) && $current['Type'] === 'ApiCallAttempt') {
return $current;
}
}
return null;
}
private static function getMaxRetriesExceeded($klass)
{
if ($klass instanceof AwsException && $klass->isMaxRetriesExceeded()) {
return 1;
}
return 0;
}
/**
* {@inheritdoc}
*/
protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
{
$event = parent::populateRequestEventData($cmd, $request, $event);
$event['Type'] = 'ApiCall';
return $event;
}
/**
* {@inheritdoc}
*/
protected function populateResultEventData($result, array $event)
{
$event = parent::populateResultEventData($result, $event);
$event['Latency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
return $event;
}
}

65
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/Configuration.php vendored Normal file
View File

@ -0,0 +1,65 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
class Configuration implements \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationInterface
{
private $clientId;
private $enabled;
private $host;
private $port;
/**
* Constructs a new Configuration object with the specified CSM options set.
*
* @param mixed $enabled
* @param string $host
* @param string|int $port
* @param string $clientId
*/
public function __construct($enabled, $host, $port, $clientId = '')
{
$this->host = $host;
$this->port = filter_var($port, FILTER_VALIDATE_INT);
if ($this->port === false) {
throw new \InvalidArgumentException("CSM 'port' value must be an integer!");
}
// Unparsable $enabled flag errors on the side of disabling CSM
$this->enabled = filter_var($enabled, FILTER_VALIDATE_BOOLEAN);
$this->clientId = trim($clientId);
}
/**
* {@inheritdoc}
*/
public function isEnabled()
{
return $this->enabled;
}
/**
* {@inheritdoc}
*/
public function getClientId()
{
return $this->clientId;
}
/**
* /{@inheritdoc}
*/
public function getHost()
{
return $this->host;
}
/**
* {@inheritdoc}
*/
public function getPort()
{
return $this->port;
}
/**
* {@inheritdoc}
*/
public function toArray()
{
return ['client_id' => $this->getClientId(), 'enabled' => $this->isEnabled(), 'host' => $this->getHost(), 'port' => $this->getPort()];
}
}

41
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ConfigurationInterface.php vendored Normal file
View File

@ -0,0 +1,41 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
/**
* Provides access to client-side monitoring configuration options:
* 'client_id', 'enabled', 'host', 'port'
*/
interface ConfigurationInterface
{
/**
* Checks whether or not client-side monitoring is enabled.
*
* @return bool
*/
public function isEnabled();
/**
* Returns the Client ID, if available.
*
* @return string|null
*/
public function getClientId();
/**
* Returns the configured host.
*
* @return string|null
*/
public function getHost();
/**
* Returns the configured port.
*
* @return int|null
*/
public function getPort();
/**
* Returns the configuration as an associative array.
*
* @return array
*/
public function toArray();
}

185
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ConfigurationProvider.php vendored Normal file
View File

@ -0,0 +1,185 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
use UglyRobot\Infinite_Uploads\Aws\AbstractConfigurationProvider;
use UglyRobot\Infinite_Uploads\Aws\CacheInterface;
use UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception\ConfigurationException;
use UglyRobot\Infinite_Uploads\Aws\ConfigurationProviderInterface;
use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
/**
* A configuration provider is a function that accepts no arguments and returns
* a promise that is fulfilled with a {@see \Aws\ClientSideMonitoring\ConfigurationInterface}
* or rejected with an {@see \Aws\ClientSideMonitoring\Exception\ConfigurationException}.
*
* <code>
* use Aws\ClientSideMonitoring\ConfigurationProvider;
* $provider = ConfigurationProvider::defaultProvider();
* // Returns a ConfigurationInterface or throws.
* $config = $provider()->wait();
* </code>
*
* Configuration providers can be composed to create configuration using
* conditional logic that can create different configurations in different
* environments. You can compose multiple providers into a single provider using
* {@see Aws\ClientSideMonitoring\ConfigurationProvider::chain}. This function
* accepts providers as variadic arguments and returns a new function that will
* invoke each provider until a successful configuration is returned.
*
* <code>
* // First try an INI file at this location.
* $a = ConfigurationProvider::ini(null, '/path/to/file.ini');
* // Then try an INI file at this location.
* $b = ConfigurationProvider::ini(null, '/path/to/other-file.ini');
* // Then try loading from environment variables.
* $c = ConfigurationProvider::env();
* // Combine the three providers together.
* $composed = ConfigurationProvider::chain($a, $b, $c);
* // Returns a promise that is fulfilled with a configuration or throws.
* $promise = $composed();
* // Wait on the configuration to resolve.
* $config = $promise->wait();
* </code>
*/
class ConfigurationProvider extends \UglyRobot\Infinite_Uploads\Aws\AbstractConfigurationProvider implements \UglyRobot\Infinite_Uploads\Aws\ConfigurationProviderInterface
{
const DEFAULT_CLIENT_ID = '';
const DEFAULT_ENABLED = false;
const DEFAULT_HOST = '127.0.0.1';
const DEFAULT_PORT = 31000;
const ENV_CLIENT_ID = 'AWS_CSM_CLIENT_ID';
const ENV_ENABLED = 'AWS_CSM_ENABLED';
const ENV_HOST = 'AWS_CSM_HOST';
const ENV_PORT = 'AWS_CSM_PORT';
const ENV_PROFILE = 'AWS_PROFILE';
public static $cacheKey = 'aws_cached_csm_config';
protected static $interfaceClass = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationInterface::class;
protected static $exceptionClass = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception\ConfigurationException::class;
/**
* Create a default config provider that first checks for environment
* variables, then checks for a specified profile in the environment-defined
* config file location (env variable is 'AWS_CONFIG_FILE', file location
* defaults to ~/.aws/config), then checks for the "default" profile in the
* environment-defined config file location, and failing those uses a default
* fallback set of configuration options.
*
* This provider is automatically wrapped in a memoize function that caches
* previously provided config options.
*
* @param array $config
*
* @return callable
*/
public static function defaultProvider(array $config = [])
{
$configProviders = [self::env()];
if (!isset($config['use_aws_shared_config_files']) || $config['use_aws_shared_config_files'] != false) {
$configProviders[] = self::ini();
}
$configProviders[] = self::fallback();
$memo = self::memoize(call_user_func_array('self::chain', $configProviders));
if (isset($config['csm']) && $config['csm'] instanceof CacheInterface) {
return self::cache($memo, $config['csm'], self::$cacheKey);
}
return $memo;
}
/**
* Provider that creates CSM config from environment variables.
*
* @return callable
*/
public static function env()
{
return function () {
// Use credentials from environment variables, if available
$enabled = getenv(self::ENV_ENABLED);
if ($enabled !== false) {
return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($enabled, getenv(self::ENV_HOST) ?: self::DEFAULT_HOST, getenv(self::ENV_PORT) ?: self::DEFAULT_PORT, getenv(self::ENV_CLIENT_ID) ?: self::DEFAULT_CLIENT_ID));
}
return self::reject('Could not find environment variable CSM config' . ' in ' . self::ENV_ENABLED . '/' . self::ENV_HOST . '/' . self::ENV_PORT . '/' . self::ENV_CLIENT_ID);
};
}
/**
* Fallback config options when other sources are not set.
*
* @return callable
*/
public static function fallback()
{
return function () {
return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration(self::DEFAULT_ENABLED, self::DEFAULT_HOST, self::DEFAULT_PORT, self::DEFAULT_CLIENT_ID));
};
}
/**
* Config provider that creates config using a config file whose location
* is specified by an environment variable 'AWS_CONFIG_FILE', defaulting to
* ~/.aws/config if not specified
*
* @param string|null $profile Profile to use. If not specified will use
* the "default" profile.
* @param string|null $filename If provided, uses a custom filename rather
* than looking in the default directory.
*
* @return callable
*/
public static function ini($profile = null, $filename = null)
{
$filename = $filename ?: self::getDefaultConfigFilename();
$profile = $profile ?: (getenv(self::ENV_PROFILE) ?: 'aws_csm');
return function () use($profile, $filename) {
if (!is_readable($filename)) {
return self::reject("Cannot read CSM config from {$filename}");
}
$data = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($filename, true);
if ($data === false) {
return self::reject("Invalid config file: {$filename}");
}
if (!isset($data[$profile])) {
return self::reject("'{$profile}' not found in config file");
}
if (!isset($data[$profile]['csm_enabled'])) {
return self::reject("Required CSM config values not present in \n INI profile '{$profile}' ({$filename})");
}
// host is optional
if (empty($data[$profile]['csm_host'])) {
$data[$profile]['csm_host'] = self::DEFAULT_HOST;
}
// port is optional
if (empty($data[$profile]['csm_port'])) {
$data[$profile]['csm_port'] = self::DEFAULT_PORT;
}
// client_id is optional
if (empty($data[$profile]['csm_client_id'])) {
$data[$profile]['csm_client_id'] = self::DEFAULT_CLIENT_ID;
}
return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($data[$profile]['csm_enabled'], $data[$profile]['csm_host'], $data[$profile]['csm_port'], $data[$profile]['csm_client_id']));
};
}
/**
* Unwraps a configuration object in whatever valid form it is in,
* always returning a ConfigurationInterface object.
*
* @param mixed $config
* @return ConfigurationInterface
* @throws \InvalidArgumentException
*/
public static function unwrap($config)
{
if (is_callable($config)) {
$config = $config();
}
if ($config instanceof PromiseInterface) {
$config = $config->wait();
}
if ($config instanceof ConfigurationInterface) {
return $config;
} elseif (is_array($config) && isset($config['enabled'])) {
$client_id = isset($config['client_id']) ? $config['client_id'] : self::DEFAULT_CLIENT_ID;
$host = isset($config['host']) ? $config['host'] : self::DEFAULT_HOST;
$port = isset($config['port']) ? $config['port'] : self::DEFAULT_PORT;
return new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($config['enabled'], $host, $port, $client_id);
}
throw new \InvalidArgumentException('Not a valid CSM configuration ' . 'argument.');
}
}

13
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/Exception/ConfigurationException.php vendored Normal file
View File

@ -0,0 +1,13 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception;
use UglyRobot\Infinite_Uploads\Aws\HasMonitoringEventsTrait;
use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
/**
* Represents an error interacting with configuration for client-side monitoring.
*/
class ConfigurationException extends \RuntimeException implements \UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface
{
use HasMonitoringEventsTrait;
}

30
wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/MonitoringMiddlewareInterface.php vendored Normal file
View File

@ -0,0 +1,30 @@
<?php
namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
/**
* @internal
*/
interface MonitoringMiddlewareInterface
{
/**
* Data for event properties to be sent to the monitoring agent.
*
* @param RequestInterface $request
* @return array
*/
public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request);
/**
* Data for event properties to be sent to the monitoring agent.
*
* @param ResultInterface|AwsException|\Exception $klass
* @return array
*/
public static function getResponseData($klass);
public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request);
}