WP File Manager

Current Path: /home/itutorethiopia/public_html/vendor/aws/aws-sdk-php/src/

Name	Action
..
ACMPCA
Acm
AlexaForBusiness
Api
ApiGateway
AppSync
ApplicationAutoScaling
ApplicationDiscoveryService
Appstream
Athena
AutoScaling
AutoScalingPlans
AwsClient.php	Edit
AwsClientInterface.php	Edit
AwsClientTrait.php	Edit
Batch
Budgets
CacheInterface.php	Edit
ClientResolver.php	Edit
Cloud9
CloudDirectory
CloudFormation
CloudFront
CloudHSMV2
CloudHsm
CloudSearch
CloudSearchDomain
CloudTrail
CloudWatch
CloudWatchEvents
CloudWatchLogs
CodeBuild
CodeCommit
CodeDeploy
CodePipeline
CodeStar
CognitoIdentity
CognitoIdentityProvider
CognitoSync
Command.php	Edit
CommandInterface.php	Edit
CommandPool.php	Edit
Comprehend
ConfigService
Connect
CostExplorer
CostandUsageReportService
Credentials
Crypto
DAX
DLM
DataPipeline
DatabaseMigrationService
DeviceFarm
DirectConnect
DirectoryService
DoctrineCacheAdapter.php	Edit
DynamoDb
DynamoDbStreams
EKS
Ec2
Ecr
Ecs
Efs
ElastiCache
ElasticBeanstalk
ElasticLoadBalancing
ElasticLoadBalancingV2
ElasticTranscoder
ElasticsearchService
Emr
Endpoint
Exception
FMS
Firehose
GameLift
Glacier
Glue
Greengrass
GuardDuty
Handler
HandlerList.php	Edit
HasDataTrait.php	Edit
HashInterface.php	Edit
HashingStream.php	Edit
Health
History.php	Edit
Iam
IdempotencyTokenMiddleware.php	Edit
ImportExport
Inspector
IoT1ClickDevicesService
IoT1ClickProjects
IoTAnalytics
IoTJobsDataPlane
Iot
IotDataPlane
JsonCompiler.php	Edit
Kinesis
KinesisAnalytics
KinesisVideo
KinesisVideoArchivedMedia
KinesisVideoMedia
Kms
Lambda
LexModelBuildingService
LexRuntimeService
Lightsail
LruArrayCache.php	Edit
MQ
MTurk
MachineLearning
Macie
MarketplaceCommerceAnalytics
MarketplaceEntitlementService
MarketplaceMetering
MediaConvert
MediaLive
MediaPackage
MediaStore
MediaStoreData
MediaTailor
Middleware.php	Edit
MigrationHub
Mobile
MockHandler.php	Edit
MultiRegionClient.php	Edit
Multipart
Neptune
OpsWorks
OpsWorksCM
Organizations
PI
PhpHash.php	Edit
Pinpoint
Polly
PresignUrlMiddleware.php	Edit
Pricing
PsrCacheAdapter.php	Edit
Rds
Redshift
Rekognition
ResourceGroups
ResourceGroupsTaggingAPI
Result.php	Edit
ResultInterface.php	Edit
ResultPaginator.php	Edit
RetryMiddleware.php	Edit
Route53
Route53Domains
S3
SageMaker
SageMakerRuntime
Sdk.php	Edit
SecretsManager
ServerlessApplicationRepository
ServiceCatalog
ServiceDiscovery
Ses
Sfn
Shield
Signature
Sms
SnowBall
Sns
Sqs
Ssm
StorageGateway
Sts
Support
Swf
TraceMiddleware.php	Edit
TranscribeService
Translate
Waf
WafRegional
Waiter.php	Edit
WorkDocs
WorkMail
WorkSpaces
WrappedHttpHandler.php	Edit
XRay
data
functions.php	Edit

Editing: WrappedHttpHandler.php

<?php
namespace Aws;

use Aws\Api\Parser\Exception\ParserException;
use GuzzleHttp\Promise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Converts an HTTP handler into a Command HTTP handler.
 *
 * HTTP handlers have the following signature:
 *     function(RequestInterface $request, array $options) : PromiseInterface
 *
 * The promise returned form an HTTP handler must resolve to a PSR-7 response
 * object when fulfilled or an error array when rejected. The error array
 * can contain the following data:
 *
 * - exception: (required, Exception) Exception that was encountered.
 * - response: (ResponseInterface) PSR-7 response that was received (if a
 *   response) was received.
 * - connection_error: (bool) True if the error is the result of failing to
 *   connect.
 */
class WrappedHttpHandler
{
    private $httpHandler;
    private $parser;
    private $errorParser;
    private $exceptionClass;
    private $collectStats;

/**
     * @param callable $httpHandler    Function that accepts a request and array
     *                                 of request options and returns a promise
     *                                 that fulfills with a response or rejects
     *                                 with an error array.
     * @param callable $parser         Function that accepts a response object
     *                                 and returns an AWS result object.
     * @param callable $errorParser    Function that parses a response object
     *                                 into AWS error data.
     * @param string   $exceptionClass Exception class to throw.
     * @param bool     $collectStats   Whether to collect HTTP transfer
     *                                 information.
     */
    public function __construct(
        callable $httpHandler,
        callable $parser,
        callable $errorParser,
        $exceptionClass = 'Aws\Exception\AwsException',
        $collectStats = false
    ) {
        $this->httpHandler = $httpHandler;
        $this->parser = $parser;
        $this->errorParser = $errorParser;
        $this->exceptionClass = $exceptionClass;
        $this->collectStats = $collectStats;
    }

/**
     * Calls the simpler HTTP specific handler and wraps the returned promise
     * with AWS specific values (e.g., a result object or AWS exception).
     *
     * @param CommandInterface $command Command being executed.
     * @param RequestInterface $request Request to send.
     *
     * @return Promise\PromiseInterface
     */
    public function __invoke(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $fn = $this->httpHandler;
        $options = $command['@http'] ?: [];
        $stats = [];
        if ($this->collectStats) {
            $options['http_stats_receiver'] = static function (
                array $transferStats
            ) use (&$stats) {
                $stats = $transferStats;
            };
        } elseif (isset($options['http_stats_receiver'])) {
            throw new \InvalidArgumentException('Providing a custom HTTP stats'
                . ' receiver to Aws\WrappedHttpHandler is not supported.');
        }

return Promise\promise_for($fn($request, $options))
            ->then(
                function (
                    ResponseInterface $res
                ) use ($command, $request, &$stats) {
                    return $this->parseResponse($command, $request, $res, $stats);
                },
                function ($err) use ($request, $command, &$stats) {
                    if (is_array($err)) {
                        $err = $this->parseError(
                            $err,
                            $request,
                            $command,
                            $stats
                        );
                    }
                    return new Promise\RejectedPromise($err);
                }
            );
    }

/**
     * @param CommandInterface  $command
     * @param RequestInterface  $request
     * @param ResponseInterface $response
     * @param array             $stats
     *
     * @return ResultInterface
     */
    private function parseResponse(
        CommandInterface $command,
        RequestInterface $request,
        ResponseInterface $response,
        array $stats
    ) {
        $parser = $this->parser;
        $status = $response->getStatusCode();
        $result = $status < 300
            ? $parser($command, $response)
            : new Result();

$metadata = [
            'statusCode'    => $status,
            'effectiveUri'  => (string) $request->getUri(),
            'headers'       => [],
            'transferStats' => [],
        ];
        if (!empty($stats)) {
            $metadata['transferStats']['http'] = [$stats];
        }

// Bring headers into the metadata array.
        foreach ($response->getHeaders() as $name => $values) {
            $metadata['headers'][strtolower($name)] = $values[0];
        }

$result['@metadata'] = $metadata;

return $result;
    }

/**
     * Parses a rejection into an AWS error.
     *
     * @param array            $err     Rejection error array.
     * @param RequestInterface $request Request that was sent.
     * @param CommandInterface $command Command being sent.
     * @param array            $stats   Transfer statistics
     *
     * @return \Exception
     */
    private function parseError(
        array $err,
        RequestInterface $request,
        CommandInterface $command,
        array $stats
    ) {
        if (!isset($err['exception'])) {
            throw new \RuntimeException('The HTTP handler was rejected without an "exception" key value pair.');
        }

$serviceError = "AWS HTTP error: " . $err['exception']->getMessage();

if (!isset($err['response'])) {
            $parts = ['response' => null];
        } else {
            try {
                $parts = call_user_func($this->errorParser, $err['response']);
                $serviceError .= " {$parts['code']} ({$parts['type']}): "
                    . "{$parts['message']} - " . $err['response']->getBody();
            } catch (ParserException $e) {
                $parts = [];
                $serviceError .= ' Unable to parse error information from '
                    . "response - {$e->getMessage()}";
            }

$parts['response'] = $err['response'];
        }

$parts['exception'] = $err['exception'];
        $parts['request'] = $request;
        $parts['connection_error'] = !empty($err['connection_error']);
        $parts['transfer_stats'] = $stats;

return new $this->exceptionClass(
            sprintf(
                'Error executing "%s" on "%s"; %s',
                $command->getName(),
                $request->getUri(),
                $serviceError
            ),
            $command,
            $parts,
            $err['exception']
        );
    }
}