← Back to branch summary

~tcuthbert/wordpress/openstack-objectstorage-k8s

« back to all changes in this revision

Viewing changes to vendor/guzzlehttp/guzzle/src/Subscriber/Prepare.php

  • Committer: Thomas Cuthbert
  • Date: 2020-04-23 05:22:45 UTC
  • Revision ID: thomas.cuthbert@canonical.com-20200423052245-1jxao3mw31w435js
[,r=trivial] bionic composer vendor update

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/guzzlehttp/guzzle/src/Subscriber/Prepare.php
 
1
<?php
 
2
namespace GuzzleHttp\Subscriber;
 
3
 
 
4
use GuzzleHttp\Event\BeforeEvent;
 
5
use GuzzleHttp\Event\RequestEvents;
 
6
use GuzzleHttp\Event\SubscriberInterface;
 
7
use GuzzleHttp\Message\AppliesHeadersInterface;
 
8
use GuzzleHttp\Message\RequestInterface;
 
9
use GuzzleHttp\Mimetypes;
 
10
use GuzzleHttp\Stream\StreamInterface;
 
11
 
 
12
/**
 
13
 * Prepares requests with a body before sending
 
14
 *
 
15
 * **Request Options**
 
16
 *
 
17
 * - expect: Set to true to enable the "Expect: 100-Continue" header for a
 
18
 *   request that send a body. Set to false to disable "Expect: 100-Continue".
 
19
 *   Set to a number so that the size of the payload must be greater than the
 
20
 *   number in order to send the Expect header. Setting to a number will send
 
21
 *   the Expect header for all requests in which the size of the payload cannot
 
22
 *   be determined or where the body is not rewindable.
 
23
 */
 
24
class Prepare implements SubscriberInterface
 
25
{
 
26
    public function getEvents()
 
27
    {
 
28
        return ['before' => ['onBefore', RequestEvents::PREPARE_REQUEST]];
 
29
    }
 
30
 
 
31
    public function onBefore(BeforeEvent $event)
 
32
    {
 
33
        $request = $event->getRequest();
 
34
 
 
35
        // Set the appropriate Content-Type for a request if one is not set and
 
36
        // there are form fields
 
37
        if (!($body = $request->getBody())) {
 
38
            return;
 
39
        }
 
40
 
 
41
        $this->addContentLength($request, $body);
 
42
 
 
43
        if ($body instanceof AppliesHeadersInterface) {
 
44
            // Synchronize the body with the request headers
 
45
            $body->applyRequestHeaders($request);
 
46
        } elseif (!$request->hasHeader('Content-Type')) {
 
47
            $this->addContentType($request, $body);
 
48
        }
 
49
 
 
50
        $this->addExpectHeader($request, $body);
 
51
    }
 
52
 
 
53
    private function addContentType(
 
54
        RequestInterface $request,
 
55
        StreamInterface $body
 
56
    ) {
 
57
        if (!($uri = $body->getMetadata('uri'))) {
 
58
            return;
 
59
        }
 
60
 
 
61
        // Guess the content-type based on the stream's "uri" metadata value.
 
62
        // The file extension is used to determine the appropriate mime-type.
 
63
        if ($contentType = Mimetypes::getInstance()->fromFilename($uri)) {
 
64
            $request->setHeader('Content-Type', $contentType);
 
65
        }
 
66
    }
 
67
 
 
68
    private function addContentLength(
 
69
        RequestInterface $request,
 
70
        StreamInterface $body
 
71
    ) {
 
72
        // Set the Content-Length header if it can be determined, and never
 
73
        // send a Transfer-Encoding: chunked and Content-Length header in
 
74
        // the same request.
 
75
        if ($request->hasHeader('Content-Length')) {
 
76
            // Remove transfer-encoding if content-length is set.
 
77
            $request->removeHeader('Transfer-Encoding');
 
78
            return;
 
79
        }
 
80
 
 
81
        if ($request->hasHeader('Transfer-Encoding')) {
 
82
            return;
 
83
        }
 
84
 
 
85
        if (null !== ($size = $body->getSize())) {
 
86
            $request->setHeader('Content-Length', $size);
 
87
            $request->removeHeader('Transfer-Encoding');
 
88
        } elseif ('1.1' == $request->getProtocolVersion()) {
 
89
            // Use chunked Transfer-Encoding if there is no determinable
 
90
            // content-length header and we're using HTTP/1.1.
 
91
            $request->setHeader('Transfer-Encoding', 'chunked');
 
92
            $request->removeHeader('Content-Length');
 
93
        }
 
94
    }
 
95
 
 
96
    private function addExpectHeader(
 
97
        RequestInterface $request,
 
98
        StreamInterface $body
 
99
    ) {
 
100
        // Determine if the Expect header should be used
 
101
        if ($request->hasHeader('Expect')) {
 
102
            return;
 
103
        }
 
104
 
 
105
        $expect = $request->getConfig()['expect'];
 
106
 
 
107
        // Return if disabled or if you're not using HTTP/1.1
 
108
        if ($expect === false || $request->getProtocolVersion() !== '1.1') {
 
109
            return;
 
110
        }
 
111
 
 
112
        // The expect header is unconditionally enabled
 
113
        if ($expect === true) {
 
114
            $request->setHeader('Expect', '100-Continue');
 
115
            return;
 
116
        }
 
117
 
 
118
        // By default, send the expect header when the payload is > 1mb
 
119
        if ($expect === null) {
 
120
            $expect = 1048576;
 
121
        }
 
122
 
 
123
        // Always add if the body cannot be rewound, the size cannot be
 
124
        // determined, or the size is greater than the cutoff threshold
 
125
        $size = $body->getSize();
 
126
        if ($size === null || $size >= (int) $expect || !$body->isSeekable()) {
 
127
            $request->setHeader('Expect', '100-Continue');
 
128
        }
 
129
    }
 
130
}