コード例 #1
0
ファイル: httpdownloader.py プロジェクト: zluca/deluge
 def connectionLost(self, reason):  # NOQA: N802
     if self.encoding:
         self.data = self.data.decode(self.encoding).encode('utf8')
     with open(self.agent.filename, 'wb') as _file:
         _file.write(self.data)
     self.finished.callback(self.agent.filename)
     self.state = u'DONE'
     HTTPClientParser.connectionLost(self, reason)
コード例 #2
0
ファイル: websocketsclient.py プロジェクト: juju/txjuju
class WebSocketsClientProtocol(WebSocketsProtocolWrapper, _FrameParser):
    """
    Client-side version of WebSocketsProtocolWrapper, performing the handshake.

    @ivar subProtocol: Once the handshake is complete, the sub-protocol that
        the server has indicated us (or C{None} if not specified).
    @type subProtocol: C{str}

    @ivar handshake: Must be set by the factory, see L{WebSocketsClientFactory}
    @type handshake: L{Handshake}.

    @ivar deferred: A deferred which will callback once the opening handshake
        has been successfully completed and the protocol is ready to send and
        receive frames, or errback with a the relevant failure otherwise. Must
        be set by the factory.
    @type deferred: C{twisted.internet.defer.Deferred}
    """
    isClient = True

    subProtocol = None
    handshake = None
    deferred = None

    _parser = None

    def connectionMade(self):
        self._buffer = []
        self._receiver.makeConnection(_FrameSender(self.transport))
        # Perform the handshake right after connecting.
        self.sendHandshake()

    def connectionLost(self, reason):
        if self._parser is not None:
            # This means we lost the connection before the handshake could
            # be complete, let's errback.
            self.deferred.errback(reason)
        else:
            # Forward the event to the user protocol
            self.wrappedProtocol.connectionLost(reason)

    def sendHandshake(self):
        """Perform a WebSocket opening handshake.

        The protocol will use the L{Handshake} parameters of the
        C{config} attribute of the factory.

        Once the handshake is complete, the C{deferred} attribute
        of the factory will be fired, either with C{None} (if the handshake
        was successful) or with a failure (if the handshake failed).
        """
        # The HTTP handshake request to send
        request = self.handshake.buildRequest()

        # We set a failing parser finisher because we take the transport
        # control back as soon as all response headers are received, so we
        # shouldn't ever deliver any data to the parser beside the headers.
        def finisher(_):
            raise RuntimeError("Parser cannot notify response finish")

        # From this point on all data we received will be forwarded to the
        # HTTP parser, see dataReceived,
        self._parser = HTTPClientParser(request, finisher)
        self._parser._responseDeferred.addCallback(self._handshakeResponse)
        self._parser._responseDeferred.addErrback(self._handshakeFailure)

        self._parser.makeConnection(self.transport)

        request.writeTo(self.transport)

    def handshakeMade(self):
        """Surrogate for connectionMade. Called after protocol negotiation."""
        self.wrappedProtocol.makeConnection(self)
        self.deferred.callback(self.wrappedProtocol)

    def abortHandshake(self, reason):
        """Abort the handshake, propagating the given error.

        @param reason: Details about the error.
        @type reason: L{twisted.python.Failure}
        """
        # Make sure we were performing the handshake
        assert self._parser is not None, "No handshake in progress"

        # This marks that the handshake has completed
        self._parser = None

        # Handshake errors are fatal, let's close the connection
        self.transport.abortConnection()
        self.deferred.errback(reason)

    def dataReceived(self, data):
        """
        Forward data to the HTTP parser if we are performing an handshake or
        process it as WebSocket payload otherwise.
        """
        if self._parser is not None:
            try:
                self._parser.dataReceived(data)
            except:
                # Disconnect the parser with the current failure, which will
                # cause the handshake deferred to errback.
                self._parser.connectionLost(Failure())
        else:
            WebSocketsProtocolWrapper.dataReceived(self, data)

    def _handshakeResponse(self, response):
        """
        Parse the HTTP response for the handshake request.
        """
        # Check the status code
        if response.code != 101:
            raise HandshakeWrongStatus(response.code)

        # Check the accept key
        accept = response.headers.getRawHeaders("Sec-WebSocket-Accept")
        if not accept or accept[0] != _makeAccept(self.handshake.key):
            raise HandshakeWrongAcceptKey(self.handshake.key, accept)

        # This marks that the handshake has completed
        self._parser = None

        # Figure out what protocol the server has chosen, if any
        protocol = response.headers.getRawHeaders("Sec-WebSocket-Protocol")
        if protocol:
            self.subProtocol = protocol[0]

        # The trasport was paused by the parser to avoid consuming non-header
        # data. Let's resume it.
        self.transport.resumeProducing()

        self.handshakeMade()

    def _handshakeFailure(self, failure):
        """
        Pass on the failure to L{abortHandshake}.
        """
        if failure.check(ResponseFailed):
            # The parser failed to parse the response, let's wrap it in
            # a HandshakeProtocolError
            failure = Failure(HandshakeProtocolError(failure.value))

        # Bail out in case of unexpected errors
        failure.trap(HandshakeError)

        self.abortHandshake(failure)

    def _parseFrames(self):
        _FrameParser._parseFrames(self)
コード例 #3
0
ファイル: base.py プロジェクト: jdrago999/lightning
    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