RequestCompressionMiddleware.php — Transferito: WP Migration trunk

transferito / vendor / aws / aws-sdk-php / src / RequestCompressionMiddleware.php

transferito / vendor / aws / aws-sdk-php / src Last commit date

RequestCompressionMiddleware.php

164 lines

1	<?php
2	namespace Aws;
3
4	use GuzzleHttp\Psr7;
5	use Psr\Http\Message\RequestInterface;
6
7	/**
8	* Used to compress request payloads if the service/operation support it.
9	*
10	* IMPORTANT: this middleware must be added after the "build" step.
11	*
12	* @internal
13	*/
14	class RequestCompressionMiddleware
15	{
16	private $api;
17	private $minimumCompressionSize;
18	private $nextHandler;
19	private $encodings;
20	private $encoding;
21	private $encodingMap = [
22	'gzip' => 'gzencode'
23	];
24
25	/**
26	* Create a middleware wrapper function.
27	*
28	* @return callable
29	*/
30	public static function wrap(array $config)
31	{
32	return function (callable $handler) use ($config) {
33	return new self($handler, $config);
34	};
35	}
36
37	public function __construct(callable $nextHandler, $config)
38	{
39	$this->minimumCompressionSize = $this->determineMinimumCompressionSize($config);
40	$this->api = $config['api'];
41	$this->nextHandler = $nextHandler;
42	}
43
44	public function __invoke(CommandInterface $command, RequestInterface $request)
45	{
46	if (isset($command['@request_min_compression_size_bytes'])
47	&& is_int($command['@request_min_compression_size_bytes'])
48	&& $this->isValidCompressionSize($command['@request_min_compression_size_bytes'])
49	) {
50	$this->minimumCompressionSize = $command['@request_min_compression_size_bytes'];
51	}
52	$nextHandler = $this->nextHandler;
53	$operation = $this->api->getOperation($command->getName());
54	$compressionInfo = isset($operation['requestcompression'])
55	? $operation['requestcompression']
56	: null;
57
58	if (!$this->shouldCompressRequestBody(
59	$compressionInfo,
60	$command,
61	$operation,
62	$request
63	)) {
64	return $nextHandler($command, $request);
65	}
66
67	$this->encodings = $compressionInfo['encodings'];
68	$request = $this->compressRequestBody($request);
69
70	return $nextHandler($command, $request);
71	}
72
73	private function compressRequestBody(
74	RequestInterface $request
75	) {
76	$fn = $this->determineEncoding();
77	if (is_null($fn)) {
78	return $request;
79	}
80
81	$body = $request->getBody()->getContents();
82	$compressedBody = $fn($body);
83
84	return $request->withBody(Psr7\Utils::streamFor($compressedBody))
85	->withHeader('content-encoding', $this->encoding);
86	}
87
88	private function determineEncoding()
89	{
90	foreach ($this->encodings as $encoding) {
91	if (isset($this->encodingMap[$encoding])) {
92	$this->encoding = $encoding;
93	return $this->encodingMap[$encoding];
94	}
95	}
96	return null;
97	}
98
99	private function shouldCompressRequestBody(
100	$compressionInfo,
101	$command,
102	$operation,
103	$request
104	){
105	if ($compressionInfo) {
106	if (isset($command['@disable_request_compression'])
107	&& $command['@disable_request_compression'] === true
108	) {
109	return false;
110	} elseif ($this->hasStreamingTraitWithoutRequiresLength($command, $operation)
111	) {
112	return true;
113	}
114
115	$requestBodySize = $request->hasHeader('content-length')
116	? (int) $request->getHeaderLine('content-length')
117	: $request->getBody()->getSize();
118
119	if ($requestBodySize >= $this->minimumCompressionSize) {
120	return true;
121	}
122	}
123	return false;
124	}
125
126	private function hasStreamingTraitWithoutRequiresLength($command, $operation)
127	{
128	foreach ($operation->getInput()->getMembers() as $name => $member) {
129	if (isset($command[$name])
130	&& !empty($member['streaming'])
131	&& empty($member['requiresLength'])
132	){
133	return true;
134	}
135	}
136	return false;
137	}
138
139	private function determineMinimumCompressionSize($config) {
140	if (is_callable($config['request_min_compression_size_bytes'])) {
141	$minCompressionSz = $config['request_min_compression_size_bytes']();
142	} else {
143	$minCompressionSz = $config['request_min_compression_size_bytes'];
144	}
145
146	if ($this->isValidCompressionSize($minCompressionSz)) {
147	return $minCompressionSz;
148	}
149	}
150
151	private function isValidCompressionSize($compressionSize)
152	{
153	if (is_numeric($compressionSize)
154	&& ($compressionSize >= 0 && $compressionSize <= 10485760)
155	) {
156	return true;
157	}
158
159	throw new \InvalidArgumentException(
160	'The minimum request compression size must be a '
161	. 'non-negative integer value between 0 and 10485760 bytes, inclusive.'
162	);
163	}
164	}