S3EndpointMiddleware::getAccelerateHost() - Code Metrics - Inspection of "Bump yiisoft/yii2 from 2.0.16 to 2.0.38" - itstructure/yii2-template-simple - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

unknown

created 2020-09-15 19:24 UTC

S3EndpointMiddleware::getAccelerateHost() A

↳ Parent: S3EndpointMiddleware

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	2
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php
namespace Aws\S3;

use Aws\CommandInterface;
use Aws\S3\Exception\S3Exception;
use 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 $nextHandler;

    /**
     * Create a middleware wrapper function
     *
     * @param string $region
     * @param array  $options
     *
     * @return callable
     */
    public static function wrap($region, array $options)
    {
        return function (callable $handler) use ($region, $options) {
            return new self($handler, $region, $options);
        };
    }

    public function __construct(
        callable $nextHandler,
        $region,
        array $options
    ) {
        $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->nextHandler = $nextHandler;
    }

    public function __invoke(CommandInterface $command, RequestInterface $request)
    {
        switch ($this->endpointPatternDecider($command, $request)) {
            case self::HOST_STYLE:
                $request = $this->applyHostStyleEndpoint($command, $request);
                break;
            case self::NO_PATTERN:
            case self::PATH_STYLE:
                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
            );
    }

    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;
        } elseif ($accelerate && $this->canAccelerate($command)) {
            return self::ACCELERATE;
        } elseif ($dualStack) {
            return self::DUALSTACK;
        } elseif (!$pathStyle
            && self::isRequestHostStyleCompatible($command, $request)
        ) {
            return self::HOST_STYLE;
        } else {
            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 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()
    {
        return "s3.dualstack.{$this->region}.amazonaws.com";
    }

    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)
    {
        return "{$command['Bucket']}.{$pattern}.amazonaws.com";
    }

    private function getBucketlessPath($path, CommandInterface $command)
    {
        $pattern = '/^\\/' . preg_quote($command['Bucket'], '/') . '/';
        return preg_replace($pattern, '', $path) ?: '/';
    }
}


1		<?php
2		namespace Aws\S3;
3
4		use Aws\CommandInterface;
5		use Aws\S3\Exception\S3Exception;
6		use Psr\Http\Message\RequestInterface;
7
8		/**
9		* Used to update the URL used for S3 requests to support:
10		* S3 Accelerate, S3 DualStack or Both. It will build to
11		* host style paths unless specified, including for S3
12		* DualStack.
13		*
14		* IMPORTANT: this middleware must be added after the "build" step.
15		*
16		* @internal
17		*/
18		class S3EndpointMiddleware
19		{
20		private static $exclusions = [
21		'CreateBucket' => true,
22		'DeleteBucket' => true,
23		'ListBuckets' => true,
24		];
25
26		const NO_PATTERN = 0;
27		const DUALSTACK = 1;
28		const ACCELERATE = 2;
29		const ACCELERATE_DUALSTACK = 3;
30		const PATH_STYLE = 4;
31		const HOST_STYLE = 5;
32
33		/** @var bool */
34		private $accelerateByDefault;
35		/** @var bool */
36		private $dualStackByDefault;
37		/** @var bool */
38		private $pathStyleByDefault;
39		/** @var string */
40		private $region;
41		/** @var callable */
42		private $nextHandler;
43
44		/**
45		* Create a middleware wrapper function
46		*
47		* @param string $region
48		* @param array $options
49		*
50		* @return callable
51		*/
52		public static function wrap($region, array $options)
53		{
54		return function (callable $handler) use ($region, $options) {
55		return new self($handler, $region, $options);
56		};
57		}
58
59		public function __construct(
60		callable $nextHandler,
61		$region,
62		array $options
63		) {
64		$this->pathStyleByDefault = isset($options['path_style'])
65		? (bool) $options['path_style'] : false;
66		$this->dualStackByDefault = isset($options['dual_stack'])
67		? (bool) $options['dual_stack'] : false;
68		$this->accelerateByDefault = isset($options['accelerate'])
69		? (bool) $options['accelerate'] : false;
70		$this->region = (string) $region;
71		$this->nextHandler = $nextHandler;
72		}
73
74		public function __invoke(CommandInterface $command, RequestInterface $request)
75		{
76		switch ($this->endpointPatternDecider($command, $request)) {
77		case self::HOST_STYLE:
78		$request = $this->applyHostStyleEndpoint($command, $request);
79		break;
80		case self::NO_PATTERN:
81		case self::PATH_STYLE:
82		break;
83		case self::DUALSTACK:
84		$request = $this->applyDualStackEndpoint($command, $request);
85		break;
86		case self::ACCELERATE:
87		$request = $this->applyAccelerateEndpoint(
88		$command,
89		$request,
90		's3-accelerate'
91		);
92		break;
93		case self::ACCELERATE_DUALSTACK:
94		$request = $this->applyAccelerateEndpoint(
95		$command,
96		$request,
97		's3-accelerate.dualstack'
98		);
99		break;
100		}
101
102		$nextHandler = $this->nextHandler;
103		return $nextHandler($command, $request);
104		}
105
106		private static function isRequestHostStyleCompatible(
107		CommandInterface $command,
108		RequestInterface $request
109		) {
110		return S3Client::isBucketDnsCompatible($command['Bucket'])
111		&& (
112		$request->getUri()->getScheme() === 'http'
113		\|\| strpos($command['Bucket'], '.') === false
114		);
115		}
116
117		private function endpointPatternDecider(
118		CommandInterface $command,
119		RequestInterface $request
120		) {
121		$accelerate = isset($command['@use_accelerate_endpoint'])
122		? $command['@use_accelerate_endpoint'] : $this->accelerateByDefault;
123		$dualStack = isset($command['@use_dual_stack_endpoint'])
124		? $command['@use_dual_stack_endpoint'] : $this->dualStackByDefault;
125		$pathStyle = isset($command['@use_path_style_endpoint'])
126		? $command['@use_path_style_endpoint'] : $this->pathStyleByDefault;
127
128		if ($accelerate && $dualStack) {
129		// When try to enable both for operations excluded from s3-accelerate,
130		// only dualstack endpoints will be enabled.
131		return $this->canAccelerate($command)
132		? self::ACCELERATE_DUALSTACK
133		: self::DUALSTACK;
134		} elseif ($accelerate && $this->canAccelerate($command)) {
135		return self::ACCELERATE;
136		} elseif ($dualStack) {
137		return self::DUALSTACK;
138		} elseif (!$pathStyle
139		&& self::isRequestHostStyleCompatible($command, $request)
140		) {
141		return self::HOST_STYLE;
142		} else {
143		return self::PATH_STYLE;
144		}
145		}
146
147		private function canAccelerate(CommandInterface $command)
148		{
149		return empty(self::$exclusions[$command->getName()])
150		&& S3Client::isBucketDnsCompatible($command['Bucket']);
151		}
152
153		private function getBucketStyleHost(CommandInterface $command, $host)
154		{
155		// For operations on the base host (e.g. ListBuckets)
156		if (!isset($command['Bucket'])) {
157		return $host;
158		}
159
160		return "{$command['Bucket']}.{$host}";
161		}
162
163	View Code Duplication	private function applyHostStyleEndpoint(
		0 ignored issues – show Duplication introduced 2019-07-21 18:11 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
164		CommandInterface $command,
165		RequestInterface $request
166		) {
167		$uri = $request->getUri();
168		$request = $request->withUri(
169		$uri->withHost($this->getBucketStyleHost(
170		$command,
171		$uri->getHost()
172		))
173		->withPath($this->getBucketlessPath(
174		$uri->getPath(),
175		$command
176		))
177		);
178		return $request;
179		}
180
181		private function applyDualStackEndpoint(
182		CommandInterface $command,
183		RequestInterface $request
184		) {
185		$request = $request->withUri(
186		$request->getUri()
187		->withHost($this->getDualStackHost())
188		);
189		if (empty($command['@use_path_style_endpoint'])
190		&& !$this->pathStyleByDefault
191		&& self::isRequestHostStyleCompatible($command, $request)
192		) {
193		$request = $this->applyHostStyleEndpoint($command, $request);
194		}
195		return $request;
196		}
197
198		private function getDualStackHost()
199		{
200		return "s3.dualstack.{$this->region}.amazonaws.com";
201		}
202
203	View Code Duplication	private function applyAccelerateEndpoint(
		0 ignored issues – show Duplication introduced 2019-07-21 18:11 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
204		CommandInterface $command,
205		RequestInterface $request,
206		$pattern
207		) {
208		$request = $request->withUri(
209		$request->getUri()
210		->withHost($this->getAccelerateHost($command, $pattern))
211		->withPath($this->getBucketlessPath(
212		$request->getUri()->getPath(),
213		$command
214		))
215		);
216		return $request;
217		}
218
219		private function getAccelerateHost(CommandInterface $command, $pattern)
220		{
221		return "{$command['Bucket']}.{$pattern}.amazonaws.com";
222		}
223
224		private function getBucketlessPath($path, CommandInterface $command)
225		{
226		$pattern = '/^\\/' . preg_quote($command['Bucket'], '/') . '/';
227		return preg_replace($pattern, '', $path) ?: '/';
228		}
229		}
230

itstructure / yii2-template-simple

Pull Request — master (#1)

S3EndpointMiddleware::getAccelerateHost() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like