コード例 #1
0
    def test_copy(self):
        """
        L{Headers.copy} creates a new independent copy of an existing
        L{Headers} instance, allowing future modifications without impacts
        between the copies.
        """
        h = Headers()
        h.setRawHeaders(u'test\u00E1', [u'foo\u2603'])
        i = h.copy()

        # The copy contains the same value as the original
        self.assertEqual(i.getRawHeaders(u'test\u00E1'), [u'foo\u2603'])
        self.assertEqual(i.getRawHeaders(b'test\xe1'), [b'foo\xe2\x98\x83'])

        # Add a header to the original
        h.addRawHeader(u'test\u00E1', u'bar')

        # Verify that the copy has not changed
        self.assertEqual(i.getRawHeaders(u'test\u00E1'), [u'foo\u2603'])
        self.assertEqual(i.getRawHeaders(b'test\xe1'), [b'foo\xe2\x98\x83'])

        # Add a header to the copy
        i.addRawHeader(u'test\u00E1', b'baz')

        # Verify that the orignal does not have it
        self.assertEqual(
            h.getRawHeaders(u'test\u00E1'), [u'foo\u2603', u'bar'])
        self.assertEqual(
            h.getRawHeaders(b'test\xe1'), [b'foo\xe2\x98\x83', b'bar'])
コード例 #2
0
    def _requestWithEndpoint(self, key, endpoint, method, parsedURI, headers,
                             bodyProducer, requestPath):
        """
        Issue a new request, given the endpoint and the path sent as part of
        the request.
        """
        # Create minimal headers, if necessary:
        if headers is None:
            headers = Headers()
        if not headers.hasHeader('host'):
            headers = headers.copy(
            )  # not supported in twisted <= 11.1, and it doesn't affects us
            headers.addRawHeader(
                'host',
                self._computeHostValue(parsedURI.scheme, parsedURI.host,
                                       parsedURI.port))

        d = self._pool.getConnection(key, endpoint)

        def cbConnected(proto):
            return proto.request(
                Request(method,
                        requestPath,
                        headers,
                        bodyProducer,
                        persistent=self._pool.persistent))

        d.addCallback(cbConnected)
        return d
コード例 #3
0
    def test_copy(self):
        """
        L{Headers.copy} creates a new independent copy of an existing
        L{Headers} instance, allowing future modifications without impacts
        between the copies.
        """
        h = Headers()
        h.setRawHeaders("test\u00E1", ["foo\u2603"])
        i = h.copy()

        # The copy contains the same value as the original
        self.assertEqual(i.getRawHeaders("test\u00E1"), ["foo\u2603"])
        self.assertEqual(i.getRawHeaders(b"test\xe1"), [b"foo\xe2\x98\x83"])

        # Add a header to the original
        h.addRawHeader("test\u00E1", "bar")

        # Verify that the copy has not changed
        self.assertEqual(i.getRawHeaders("test\u00E1"), ["foo\u2603"])
        self.assertEqual(i.getRawHeaders(b"test\xe1"), [b"foo\xe2\x98\x83"])

        # Add a header to the copy
        i.addRawHeader("test\u00E1", b"baz")

        # Verify that the orignal does not have it
        self.assertEqual(h.getRawHeaders("test\u00E1"), ["foo\u2603", "bar"])
        self.assertEqual(h.getRawHeaders(b"test\xe1"),
                         [b"foo\xe2\x98\x83", b"bar"])
コード例 #4
0
ファイル: badhack.py プロジェクト: tomprince/agentforhire
    def request(self, method, uri, headers=None, bodyProducer=None):
        parsedURI = client._parse(uri)
        
        host_addr = address.IPv4Address('TCP', parsedURI.host, parsedURI.port)
        
        
        # ripped from _AgentBase._requestWithEndpoint
        if headers is None:
            headers = Headers()
        if not headers.hasHeader('host'):
            headers = headers.copy()
            headers.addRawHeader(
                'host', self._computeHostValue(parsedURI.scheme, parsedURI.host,
                                               parsedURI.port))
        request = client.Request(method, parsedURI.path, headers, bodyProducer,
                                 persistent=False)

        c = ClientProtocol(request)
        
        # ouch
        self.root.putChild('', self.root)
        
        server = Site(self.root).buildProtocol(self.addr)
        loopbackAsync(server, c, host_addr, self.addr)
        return c.response.addBoth(self._done, c)
コード例 #5
0
ファイル: client.py プロジェクト: PeterLUYP/2016YCProject
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Issue a new request to the wrapped L{Agent}.

        Send a I{Cookie} header if a cookie for C{uri} is stored in
        L{CookieAgent.cookieJar}. Cookies are automatically extracted and
        stored from requests.

        If a C{'cookie'} header appears in C{headers} it will override the
        automatic cookie header obtained from the cookie jar.

        @see: L{Agent.request}
        """
        if headers is None:
            headers = Headers()
        lastRequest = _FakeUrllib2Request(uri)
        # Setting a cookie header explicitly will disable automatic request
        # cookies.
        if not headers.hasHeader('cookie'):
            self.cookieJar.add_cookie_header(lastRequest)
            cookieHeader = lastRequest.get_header('Cookie', None)
            if cookieHeader is not None:
                headers = headers.copy()
                headers.addRawHeader('cookie', cookieHeader)

        d = self._agent.request(method, uri, headers, bodyProducer)
        d.addCallback(self._extractCookies, lastRequest)
        return d
コード例 #6
0
ファイル: client.py プロジェクト: GunioRobot/twisted
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Issue a new request to the wrapped L{Agent}.

        Send a I{Cookie} header if a cookie for C{uri} is stored in
        L{CookieAgent.cookieJar}. Cookies are automatically extracted and
        stored from requests.

        If a C{'cookie'} header appears in C{headers} it will override the
        automatic cookie header obtained from the cookie jar.

        @see: L{Agent.request}
        """
        if headers is None:
            headers = Headers()
        lastRequest = _FakeUrllib2Request(uri)
        # Setting a cookie header explicitly will disable automatic request
        # cookies.
        if not headers.hasHeader('cookie'):
            self.cookieJar.add_cookie_header(lastRequest)
            cookieHeader = lastRequest.get_header('Cookie', None)
            if cookieHeader is not None:
                headers = headers.copy()
                headers.addRawHeader('cookie', cookieHeader)

        d = self._agent.request(method, uri, headers, bodyProducer)
        d.addCallback(self._extractCookies, lastRequest)
        return d
コード例 #7
0
    def _connectAndRequest(self,
                           method,
                           uri,
                           headers,
                           bodyProducer,
                           requestPath=None):
        """
        Internal helper to make the request.

        @param requestPath: If specified, the path to use for the request
            instead of the path extracted from C{uri}.
        """
        scheme, host, port, path = _parse(uri)
        if requestPath is None:
            requestPath = path
        d = self._connect(scheme, host, port)
        if headers is None:
            headers = Headers()
        if not headers.hasHeader('host'):
            headers = headers.copy()
            headers.addRawHeader('host',
                                 self._computeHostValue(scheme, host, port))

        def cbConnected(proto):
            return proto.request(
                Request(method, requestPath, headers, bodyProducer))

        d.addCallback(cbConnected)
        return d
コード例 #8
0
    def fetch(self, uri, headers=None):
        headers = Headers() if headers is None else headers.copy()
        headers.setRawHeaders(b'referer', ['https://www.pixiv.net/'])
        headers.setRawHeaders(b'host', [self.host])

        if (self.port == 80 and self.scheme == 'http://') \
                or (self.port == 443 and self.scheme == 'https://') \
                or self.port is None:
            url = self.scheme + self.host
        else:
            url = self.scheme + self.host + ':' + str(self.port)

        url = url + uri

        dfd = self.agent.request('GET', url, headers)
        dfd.addErrback(self.on_failure)

        def _wait_body(response):
            body_dfd = readBody(response)
            body_dfd.addCallback(lambda b: setattr(response, 'body', b))
            body_dfd.addCallback(lambda _: response)
            return body_dfd

        dfd.addCallback(_wait_body)

        return dfd
コード例 #9
0
ファイル: http.py プロジェクト: kxz/omnipresence
 def request(self, method, uri, headers=None, bodyProducer=None):
     if headers is None:
         headers = Headers()
     else:
         headers = headers.copy()
     if not headers.hasHeader('user-agent'):
         headers.addRawHeader('user-agent', self.user_agent)
     return self.agent.request(method, uri, headers, bodyProducer)
コード例 #10
0
ファイル: http.py プロジェクト: seraphlnWu/creditor
 def request(self, method, uri, headers=None, bodyProducer=None):
     if headers is None:
         headers = Headers()
     else:
         headers = headers.copy()
     for name, value in self._header_list:
         headers.addRawHeader(name, value)
     return self._agent.request(method, uri, headers, bodyProducer)
コード例 #11
0
    def request(self, method, url, headers=None, bodyProducer=None):
        """
        Issue a request with some extra headers.

        :see: ``twisted.web.iweb.IAgent.request``
        """
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()
        for k, vs in self._to_inject.getAllRawHeaders():
            headers.setRawHeaders(k, vs)
        return self._agent.request(method, url, headers, bodyProducer)
コード例 #12
0
ファイル: client.py プロジェクト: PeterLUYP/2016YCProject
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Send a client request which declares supporting compressed content.

        @see: L{Agent.request}.
        """
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()
        headers.addRawHeader('accept-encoding', self._supported)
        deferred = self._agent.request(method, uri, headers, bodyProducer)
        return deferred.addCallback(self._handleResponse)
コード例 #13
0
ファイル: client.py プロジェクト: GunioRobot/twisted
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Send a client request which declares supporting compressed content.

        @see: L{Agent.request}.
        """
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()
        headers.addRawHeader('accept-encoding', self._supported)
        deferred = self._agent.request(method, uri, headers, bodyProducer)
        return deferred.addCallback(self._handleResponse)
コード例 #14
0
ファイル: test_http_headers.py プロジェクト: pelluch/VTK
 def test_copy(self):
     """
     L{Headers.copy} creates a new independant copy of an existing
     L{Headers} instance, allowing future modifications without impacts
     between the copies.
     """
     h = Headers()
     h.setRawHeaders(b"test", [b"foo"])
     i = h.copy()
     self.assertEqual(i.getRawHeaders(b"test"), [b"foo"])
     h.addRawHeader(b"test", b"bar")
     self.assertEqual(i.getRawHeaders(b"test"), [b"foo"])
     i.addRawHeader(b"test", b"baz")
     self.assertEqual(h.getRawHeaders(b"test"), [b"foo", b"bar"])
コード例 #15
0
 def test_copy(self):
     """
     L{Headers.copy} creates a new independant copy of an existing
     L{Headers} instance, allowing future modifications without impacts
     between the copies.
     """
     h = Headers()
     h.setRawHeaders(b'test', [b'foo'])
     i = h.copy()
     self.assertEqual(i.getRawHeaders(b'test'), [b'foo'])
     h.addRawHeader(b'test', b'bar')
     self.assertEqual(i.getRawHeaders(b'test'), [b'foo'])
     i.addRawHeader(b'test', b'baz')
     self.assertEqual(h.getRawHeaders(b'test'), [b'foo', b'bar'])
コード例 #16
0
 def test_copy(self):
     """
     L{Headers.copy} creates a new independent copy of an existing
     L{Headers} instance, allowing future modifications without impacts
     between the copies.
     """
     h = Headers()
     h.setRawHeaders(b"test", [b"foo"])
     i = h.copy()
     self.assertEqual(i.getRawHeaders(b"test"), [b"foo"])
     h.addRawHeader(b"test", b"bar")
     self.assertEqual(i.getRawHeaders(b"test"), [b"foo"])
     i.addRawHeader(b"test", b"baz")
     self.assertEqual(h.getRawHeaders(b"test"), [b"foo", b"bar"])
コード例 #17
0
 def test_copy(self):
     """
     L{Headers.copy} creates a new independant copy of an existing
     L{Headers} instance, allowing future modifications without impacts
     between the copies.
     """
     h = Headers()
     h.setRawHeaders('test', ['foo'])
     i = h.copy()
     self.assertEquals(i.getRawHeaders('test'), ['foo'])
     h.addRawHeader('test', 'bar')
     self.assertEquals(i.getRawHeaders('test'), ['foo'])
     i.addRawHeader('test', 'baz')
     self.assertEquals(h.getRawHeaders('test'), ['foo', 'bar'])
コード例 #18
0
ファイル: EQ_Alert.py プロジェクト: seilexta/PSO2Proxy
def CheckupURL():
    HTTPHeader0 = Headers({'User-Agent': ['PSO2Proxy']}) #We need to send a User-Agent
    if eqalert_config.key_exists('api'):
        eq_URL = eqalert_config.get_key('api')
    else:
        eq_URL = None
    if eq_URL:
        HTTPHeaderX = HTTPHeader0.copy()
        if ETag_Header:
            HTTPHeaderX.addRawHeader('If-None-Match', ETag_Header)
        if Modified_Header:
            HTTPHeaderX.addRawHeader('If-Modified-Since', Modified_Header)
        EQ0 = agent.request('GET', eq_URL, HTTPHeaderX)
        EQ0.addCallback(EQResponse)
        EQ0.addErrback(log.err)
コード例 #19
0
def CheckupURL():
    HTTPHeader0 = Headers({'User-Agent': ['PSO2Proxy']})
    load_eqJP_names()  # Reload file
    for shipNum in config.globalConfig.get_key('enabledShips'):
        if eqnotice_config.key_exists(str(shipNum)):
            eq_URL = eqnotice_config.get_key(str(shipNum))
        else:
            eq_URL = None
        if eq_URL:
            HTTPHeaderX = HTTPHeader0.copy()
            if ETag_Headers[shipNum]:
                HTTPHeaderX.addRawHeader('If-None-Match', ETag_Headers[shipNum])
            if Modified_Headers[shipNum]:
                HTTPHeaderX.addRawHeader('If-Modified-Since', Modified_Headers[shipNum])
            EQ0 = agent.request('GET', eq_URL, HTTPHeaderX)
            EQ0.addCallback(EQResponse, shipNum)
            EQ0.addErrback(log.err)
コード例 #20
0
ファイル: EQ_Alert.py プロジェクト: kennywfl/PSO2Proxy
def CheckupURL():
    if eqalert_config.key_exists('User-Agent'):  # We need to send a User-Agent
        HTTPHeader0 = Headers({'User-Agent': [eqalert_config['User-Agent']]})
    else:
        HTTPHeader0 = Headers({'User-Agent': ['PSO2Proxy']})
    if eqalert_config.key_exists('api'):
        eq_URL = eqalert_config['api']
    else:
        eq_URL = None
    if eq_URL:
        HTTPHeaderX = HTTPHeader0.copy()
        if ETag_Header:
            HTTPHeaderX.addRawHeader('If-None-Match', ETag_Header)
        if Modified_Header:
            HTTPHeaderX.addRawHeader('If-Modified-Since', Modified_Header)
        EQ0 = agent.request('GET', eq_URL, HTTPHeaderX)
        EQ0.addCallback(EQResponse)
        EQ0.addErrback(log.err)
コード例 #21
0
def CheckupURL():
    try:
        HTTPHeader0 = Headers({'User-Agent':
                               ['PSO2Proxy']})  #We need to send a User-Agent
        if eqalert_config.key_exists('api'):
            eq_URL = eqalert_config.get_key('api')
        else:
            eq_URL = None
        if eq_URL:
            HTTPHeaderX = HTTPHeader0.copy()
            if ETag_Header:
                HTTPHeaderX.addRawHeader('If-None-Match', ETag_Header)
            if Modified_Header:
                HTTPHeaderX.addRawHeader('If-Modified-Since', Modified_Header)
            #EQ0 = agent.request('GET', eq_URL, HTTPHeaderX)
            EQ0 = agent.request('GET', eq_URL)
            EQ0.addCallback(EQResponse)
            EQ0.addErrback(log.err)
    except Exception as ex1:
        print("[EQ Alert] Opps Sorry, %s" % ex1)
コード例 #22
0
    def request(self, method, uri, headers, bodyProducer):

        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()

        contentType = headers.getRawHeaders('content-type', [""])[0]
        date = headers.getRawHeaders('date',
                                     [""])[0] or self._generateRequestDate(uri)
        headers.setRawHeaders('date', [date])

        uri_origin_form = URI.fromBytes(uri).originForm
        contentMD5 = headers.getRawHeaders('content-md5', [""])[0]

        if not contentMD5 and bodyProducer is not None:

            r = getattr(self.agent, '_reactor') or reactor
            bodyConsumer = StringConsumer(callLater=r.callLater)

            yield bodyProducer.startProducing(bodyConsumer)
            body = bodyConsumer.value()
            bodyProducer = StringBodyProducer(body)

            if body:
                contentMD5 = binascii.b2a_base64(
                    hashlib.md5(body).digest()).strip()
                headers.addRawHeader('content-md5', contentMD5)

        sts = "\n".join([
            method, contentType or "", contentMD5, date or "", uri_origin_form
        ])
        mac = hmac.new(self.secretKey, sts, digestmod=hashlib.sha1).digest()
        encodedMAC = binascii.b2a_base64(mac).strip()

        auth_header = "AuthHMAC {0}:{1}".format(self.accessKey, encodedMAC)
        headers.addRawHeader('authorization', auth_header)

        d = yield self.agent.request(method, uri, headers, bodyProducer)
        self._handleResponseDate(uri, d)
        defer.returnValue(d)
コード例 #23
0
ファイル: signing.py プロジェクト: GaretJax/txs3
    def _requestWithEndpoint(self, key, endpoint, method, parsedURI,
                             headers, bodyProducer, requestPath):
        if headers is None:
            headers = Headers()

        if not headers.hasHeader('host'):
            headers = headers.copy()
            headers.addRawHeader(
                'host', self._computeHostValue(parsedURI.scheme,
                                               parsedURI.host, parsedURI.port))

        d = self._pool.getConnection(key, endpoint)

        def cbConnected(proto):
            return proto.request(
                SigningRequest._construct(self._signData.makeSigner(),
                                          method, requestPath, headers,
                                          bodyProducer,
                                          persistent=self._pool.persistent,
                                          parsedURI=parsedURI))
        d.addCallback(cbConnected)
        return d
コード例 #24
0
    def _requestWithEndpoint(self, key, endpoint, method, parsedURI,
                             headers, bodyProducer, requestPath):
        """
        Issue a new request, given the endpoint and the path sent as part of
        the request.
        """
        # Create minimal headers, if necessary:
        if headers is None:
            headers = Headers()
        if not headers.hasHeader('host'):
            headers = headers.copy()  # not supported in twisted <= 11.1, and it doesn't affects us
            headers.addRawHeader(
                'host', self._computeHostValue(parsedURI.scheme, parsedURI.host,
                                               parsedURI.port))

        d = self._pool.getConnection(key, endpoint)
        def cbConnected(proto):
            return proto.request(
                Request(method, requestPath, headers, bodyProducer,
                        persistent=self._pool.persistent))
        d.addCallback(cbConnected)
        return d
コード例 #25
0
ファイル: client.py プロジェクト: GunioRobot/twisted
    def _connectAndRequest(self, method, uri, headers, bodyProducer,
                           requestPath=None):
        """
        Internal helper to make the request.

        @param requestPath: If specified, the path to use for the request
            instead of the path extracted from C{uri}.
        """
        scheme, host, port, path = _parse(uri)
        if requestPath is None:
            requestPath = path
        d = self._connect(scheme, host, port)
        if headers is None:
            headers = Headers()
        if not headers.hasHeader('host'):
            headers = headers.copy()
            headers.addRawHeader(
                'host', self._computeHostValue(scheme, host, port))
        def cbConnected(proto):
            return proto.request(
                Request(method, requestPath, headers, bodyProducer))
        d.addCallback(cbConnected)
        return d
コード例 #26
0
ファイル: authhmac.py プロジェクト: wgnet/twoost
    def request(self, method, uri, headers, bodyProducer):

        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()

        contentType = headers.getRawHeaders('content-type', [""])[0]
        date = headers.getRawHeaders('date', [""])[0] or self._generateRequestDate(uri)
        headers.setRawHeaders('date', [date])

        uri_origin_form = URI.fromBytes(uri).originForm
        contentMD5 = headers.getRawHeaders('content-md5', [""])[0]

        if not contentMD5 and bodyProducer is not None:

            r = getattr(self.agent, '_reactor') or reactor
            bodyConsumer = StringConsumer(callLater=r.callLater)

            yield bodyProducer.startProducing(bodyConsumer)
            body = bodyConsumer.value()
            bodyProducer = StringBodyProducer(body)

            if body:
                contentMD5 = binascii.b2a_base64(hashlib.md5(body).digest()).strip()
                headers.addRawHeader('content-md5', contentMD5)

        sts = "\n".join([method, contentType or "", contentMD5, date or "", uri_origin_form])
        mac = hmac.new(self.secretKey, sts, digestmod=hashlib.sha1).digest()
        encodedMAC = binascii.b2a_base64(mac).strip()

        auth_header = "AuthHMAC {0}:{1}".format(self.accessKey, encodedMAC)
        headers.addRawHeader('authorization', auth_header)

        d = yield self.agent.request(method, uri, headers, bodyProducer)
        self._handleResponseDate(uri, d)
        defer.returnValue(d)
コード例 #27
0
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Args:
            method (bytes): HTTP method: GET/POST/etc

            uri (bytes): Absolute URI to be retrieved

            headers (twisted.web.http_headers.Headers|None):
                HTTP headers to send with the request, or None to
                send no extra headers.

            bodyProducer (twisted.web.iweb.IBodyProducer|None):
                An object which can generate bytes to make up the
                body of this request (for example, the properly encoded contents of
                a file for a file upload).  Or None if the request is to have
                no body.

        Returns:
            Deferred[twisted.web.iweb.IResponse]:
                fires when the header of the response has been received (regardless of the
                response status code). Fails if there is any problem which prevents that
                response from being received (including problems that prevent the request
                from being sent).
        """
        parsed_uri = URI.fromBytes(uri, defaultPort=-1)
        res = yield self._route_matrix_uri(parsed_uri)

        # set up the TLS connection params
        #
        # XXX disabling TLS is really only supported here for the benefit of the
        # unit tests. We should make the UTs cope with TLS rather than having to make
        # the code support the unit tests.
        if self._tls_client_options_factory is None:
            tls_options = None
        else:
            tls_options = self._tls_client_options_factory.get_options(
                res.tls_server_name.decode("ascii"))

        # make sure that the Host header is set correctly
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()

        if not headers.hasHeader(b"host"):
            headers.addRawHeader(b"host", res.host_header)

        class EndpointFactory(object):
            @staticmethod
            def endpointForURI(_uri):
                ep = LoggingHostnameEndpoint(self._reactor, res.target_host,
                                             res.target_port)
                if tls_options is not None:
                    ep = wrapClientTLS(tls_options, ep)
                return ep

        agent = Agent.usingEndpointFactory(self._reactor, EndpointFactory(),
                                           self._pool)
        res = yield make_deferred_yieldable(
            agent.request(method, uri, headers, bodyProducer))
        return res
コード例 #28
0
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        Args:
            method (bytes): HTTP method: GET/POST/etc
            uri (bytes): Absolute URI to be retrieved
            headers (twisted.web.http_headers.Headers|None):
                HTTP headers to send with the request, or None to
                send no extra headers.
            bodyProducer (twisted.web.iweb.IBodyProducer|None):
                An object which can generate bytes to make up the
                body of this request (for example, the properly encoded contents of
                a file for a file upload).  Or None if the request is to have
                no body.
        Returns:
            Deferred[twisted.web.iweb.IResponse]:
                fires when the header of the response has been received (regardless of the
                response status code). Fails if there is any problem which prevents that
                response from being received (including problems that prevent the request
                from being sent).
        """
        # We use urlparse as that will set `port` to None if there is no
        # explicit port.
        parsed_uri = urllib.parse.urlparse(uri)

        # If this is a matrix:// URI check if the server has delegated matrix
        # traffic using well-known delegation.
        #
        # We have to do this here and not in the endpoint as we need to rewrite
        # the host header with the delegated server name.
        delegated_server = None
        if (parsed_uri.scheme == b"matrix"
                and not _is_ip_literal(parsed_uri.hostname)
                and not parsed_uri.port):
            well_known_result = yield self._well_known_resolver.get_well_known(
                parsed_uri.hostname)
            delegated_server = well_known_result.delegated_server

        if delegated_server:
            # Ok, the server has delegated matrix traffic to somewhere else, so
            # lets rewrite the URL to replace the server with the delegated
            # server name.
            uri = urllib.parse.urlunparse((
                parsed_uri.scheme,
                delegated_server,
                parsed_uri.path,
                parsed_uri.params,
                parsed_uri.query,
                parsed_uri.fragment,
            ))
            parsed_uri = urllib.parse.urlparse(uri)

        # We need to make sure the host header is set to the netloc of the
        # server and that a user-agent is provided.
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()

        if not headers.hasHeader(b"host"):
            headers.addRawHeader(b"host", parsed_uri.netloc)
        if not headers.hasHeader(b"user-agent"):
            headers.addRawHeader(b"user-agent", self.user_agent)

        res = yield make_deferred_yieldable(
            self._agent.request(method, uri, headers, bodyProducer))

        return res
コード例 #29
0
ファイル: httprpc.py プロジェクト: xdrew/twoost
 def request(self, method, uri, headers=None, bodyProducer=None):
     headers = Headers() if headers is None else headers.copy()
     headers.addRawHeader(b'authorization', self._auth_header)
     return self._agent.request(method, uri, headers, bodyProducer)
コード例 #30
0
    def request(self, method, uri, headers=None, bodyProducer=None):
        """
        :param method: HTTP method (GET/POST/etc).
        :type method: bytes

        :param uri: Absolute URI to be retrieved.
        :type uri: bytes

        :param headers: HTTP headers to send with the request, or None to
            send no extra headers.
        :type headers: twisted.web.http_headers.Headers, None

        :param bodyProducer: An object which can generate bytes to make up the
            body of this request (for example, the properly encoded contents of
            a file for a file upload).  Or None if the request is to have
            no body.
        :type bodyProducer: twisted.web.iweb.IBodyProducer, None

        :returns a deferred that fires when the header of the response has
            been received (regardless of the response status code). Fails if
            there is any problem which prevents that response from being received
            (including problems that prevent the request from being sent).
        :rtype: Deferred[twisted.web.iweb.IResponse]
        """
        parsed_uri = URI.fromBytes(uri, defaultPort=-1)
        res = yield self._route_matrix_uri(parsed_uri)

        # set up the TLS connection params
        #
        # XXX disabling TLS is really only supported here for the benefit of the
        # unit tests. We should make the UTs cope with TLS rather than having to make
        # the code support the unit tests.
        if self._tls_client_options_factory is None:
            tls_options = None
        else:
            tls_options = self._tls_client_options_factory.get_options(
                res.tls_server_name.decode("ascii")
            )

        # make sure that the Host header is set correctly
        if headers is None:
            headers = Headers()
        else:
            headers = headers.copy()

        if not headers.hasHeader(b'host'):
            headers.addRawHeader(b'host', res.host_header)

        class EndpointFactory(object):
            @staticmethod
            def endpointForURI(_uri):
                ep = LoggingHostnameEndpoint(
                    self._reactor, res.target_host, res.target_port,
                )
                if tls_options is not None:
                    ep = wrapClientTLS(tls_options, ep)
                return ep

        agent = Agent.usingEndpointFactory(self._reactor, EndpointFactory(), self._pool)
        res = yield agent.request(method, uri, headers, bodyProducer)
        defer.returnValue(res)
コード例 #31
0
ファイル: httprpc.py プロジェクト: anjensan/twoost
 def request(self, method, uri, headers=None, bodyProducer=None):
     headers = Headers() if headers is None else headers.copy()
     headers.addRawHeader(b'authorization', self._auth_header)
     return self._agent.request(method, uri, headers, bodyProducer)