Exemplo n.º 1
0
 def from_dict(cls, dct):
     """Create a new cassette from *dct*, as deserialized from JSON
     or YAML format."""
     cassette = cls()
     for interaction in dct['http_interactions']:
         rq = interaction['request']
         # Overwrite the scheme and netloc, leaving just the part of
         # the URI that would be sent in a real request.
         relative_uri = urlunparse(('', '') + urlparse(rq['uri'])[2:])
         request = Request._construct(
             rq['method'], relative_uri, Headers(rq['headers']),
             SavedBodyProducer(body_from_dict(rq)),
             False, URI.fromBytes(rq['uri'].encode('utf-8')))
         rp = interaction['response']
         response = Response._construct(
             ('HTTP', 1, 1), rp['status']['code'], rp['status']['message'],
             Headers(rp['headers']), AbortableStringTransport(), request)
         content_length = response.headers.getRawHeaders('Content-Length')
         if content_length:
             try:
                 response.length = int(content_length[0])
             except ValueError:
                 pass
         cassette.responses.append(
             SavedResponse(response, body_from_dict(rp)))
     return cassette
Exemplo n.º 2
0
 def cbConnected(proto):
     return proto.request(
         Request(method,
                 requestPath,
                 headers,
                 bodyProducer,
                 persistent=self._pool.persistent))
Exemplo n.º 3
0
    def allHeadersReceived(self):
        parts = self.status.split(' ', 2)
        if len(parts) != 3:
            raise ParseError("wrong number of parts", self.status)
        method, request_uri, _ = parts

        if method == 'GET':
            self.contentLength = 0
        else:
            self.contentLength = self.parseContentLength(self.connHeaders)
            print "HTTPServerParser Header's Content length", self.contentLength
            # TOFIX: need to include a bodyProducer with the request
            # so that it knows to set a content-length
            self.switchToBodyMode(self._bodyDecoder)
        self.requestParsed(Request(method, request_uri, self.headers, None))
        if self.contentLength == 0:
            self._finished(self.clearLineBuffer())
Exemplo n.º 4
0
    def buildRequest(self):
        """Build the HTTP request used to start this handshake."""
        # Required headers
        headers = {
            "Host": [self.host],
            "Upgrade": ["WebSocket"],
            "Connection": ["Upgrade"],
            "Sec-WebSocket-Key": [self.key],
            "Sec-WebSocket-Version": ["13"]
        }

        # Optional headers
        if self.origin is not None:
            headers["Origin"] = [self.origin]
        if self.protocol is not None:
            headers["Sec-WebSocket-Protocol"] = self.protocol

        return Request("GET",
                       self.path,
                       Headers(headers),
                       bodyProducer=None,
                       persistent=True)
Exemplo n.º 5
0
 def cbConnected(proto):
     # NOTE: For the proxy case the path should be the full URI.
     return proto.request(
         Request(method, request_path, headers, bodyProducer))
Exemplo n.º 6
0
 def cbConnected(proto):
     return proto.request(Request(method, path, headers, bodyProducer))
Exemplo n.º 7
0
    def fetch(self, path, list_as_set=False, **kwargs):
        if type(kwargs.get('postdata', None)) == dict:
            kwargs['postdata'] = urlencode(kwargs['postdata'], doseq=True)

        if self.use_networking:
            dResponse = cyclone.httpclient.fetch(
                url=self.getUrl(path=path), **kwargs
            )
        else:
            from cyclone.httpclient import Receiver
            from twisted.web._newclient import Request, Response
            from twisted.web.http_headers import Headers
            from twisted.test.proto_helpers import AccumulatingProtocol

            server_proto = self.app.buildProtocol( ('127.0.0.1', 0) )
            server_transport = proto_helpers.StringTransport()
            server_proto.makeConnection(server_transport)

            rawHeaders = kwargs.get('headers', {})
            rawHeaders['Host'] = ['localhost']
            req = Request(
                method=kwargs['method'],
                uri=path,
                headers=Headers( rawHeaders=rawHeaders ),
                bodyProducer=None,
            )
            req.writeTo(server_transport)
            server_proto.dataReceived(server_transport.value())
            print server_transport.value()

            # Strip out the original request.
            parts = server_transport.value().split("\r\n\r\n")
            actual_response = "\r\n\r\n".join(parts[1:])

            print actual_response

            from twisted.web._newclient import HTTPClientParser
            client_parser = HTTPClientParser(req, lambda x:x)
            client_parser.makeConnection(proto_helpers.StringTransport())
            client_parser.dataReceived(actual_response)
            response = client_parser.response

            # This was done in cyclone.httpclient
            if response.code in (204, 304):
                response.body = ''
                dResponse = defer.succeed(response)
            else:
                dResponse = defer.Deferred()
                response.deliverBody(Receiver(dResponse))
                def set_response(value):
                    response.body = value
                    return response
                dResponse.addCallback(set_response)

            # This triggers response.deliverBody. It needs a reason of some kind
            client_parser.connectionLost('Finished')

        if list_as_set:
            def decode_body(res):
                res.body = json.loads(res.body, object_hook=decode_list_as_set)
                return res
            dResponse.addCallback(decode_body)
        else:
            def decode_body(res):
                try:
                    res.body = json.loads(res.body)
                except:
                    print "counld not parse body: %s" % res.body
                return res
            dResponse.addCallback(decode_body)

        return dResponse