request -> request_method

libmproxy/protocol/http.py

@@ -41,7 +41,7 @@ def send_connect_request(conn, host, port, update_state=True):
     protocol = http1.HTTP1Protocol(conn)
 
     conn.send(protocol.assemble(upstream_request))
-    resp = HTTPResponse.from_protocol(protocol, upstream_request)
+    resp = HTTPResponse.from_protocol(protocol, upstream_request.method)
     if resp.status_code != 200:
         raise proxy.ProxyError(resp.status_code,
                                "Cannot establish SSL " +
@@ -177,7 +177,7 @@ class HTTPHandler(ProtocolHandler):
                 # Only get the headers at first...
                 flow.response = HTTPResponse.from_protocol(
                     self.c.server_conn.protocol,
-                    flow.request,
+                    flow.request.method,
                     body_size_limit=self.c.config.body_size_limit,
                     include_body=False,
                 )
@@ -760,7 +760,7 @@ class RequestReplayThread(threading.Thread):
                 self.flow.server_conn.protocol = http1.HTTP1Protocol(self.flow.server_conn)
                 self.flow.response = HTTPResponse.from_protocol(
                     self.flow.server_conn.protocol,
-                    r,
+                    r.method,
                     body_size_limit=self.config.body_size_limit,
                 )
             if self.channel:

libmproxy/protocol/http_wrappers.py

@@ -240,13 +240,10 @@ class HTTPRequest(MessageMixin, semantics.Request):
     def from_protocol(
             self,
             protocol,
-            include_body=True,
-            body_size_limit=None,
+            *args,
+            **kwargs
     ):
-        req = protocol.read_request(
-            include_body = include_body,
-            body_size_limit = body_size_limit,
-        )
+        req = protocol.read_request(*args, **kwargs)
         return self.wrap(req)
 
     @classmethod
@@ -352,15 +349,10 @@ class HTTPResponse(MessageMixin, semantics.Response):
     def from_protocol(
             self,
             protocol,
-            request,
-            include_body=True,
-            body_size_limit=None
+            *args,
+            **kwargs
     ):
-        resp = protocol.read_response(
-            request,
-            body_size_limit,
-            include_body=include_body
-        )
+        resp = protocol.read_response(*args, **kwargs)
         return self.wrap(resp)
 
     @classmethod

libmproxy/protocol2/http.py

@@ -34,10 +34,10 @@ class Http1Layer(Layer):
             body_size_limit=self.config.body_size_limit
         )
 
-    def read_from_server(self, request):
+    def read_from_server(self, request_method):
         return HTTPResponse.from_protocol(
             self.server_protocol,
-            request,
+            request_method,
             body_size_limit=self.config.body_size_limit,
             include_body=False,
         )
@@ -64,6 +64,7 @@ class Http1Layer(Layer):
         layer = HttpLayer(self, self.mode)
         layer()
 
+
 class Http2Layer(Layer):
     def __init__(self, ctx, mode):
         super(Http2Layer, self).__init__(ctx)
@@ -72,20 +73,20 @@ class Http2Layer(Layer):
         self.server_protocol = HTTP2Protocol(self.server_conn, is_server=False, unhandled_frame_cb=self.handle_unexpected_frame)
 
     def read_from_client(self):
-        return HTTPRequest.from_protocol(
+        request = HTTPRequest.from_protocol(
             self.client_protocol,
             body_size_limit=self.config.body_size_limit
         )
+        self._stream_id = request.stream_id
 
-    def read_from_server(self, request):
-        response = HTTPResponse.from_protocol(
+    def read_from_server(self, request_method):
+        return HTTPResponse.from_protocol(
             self.server_protocol,
-            request,
+            request_method,
             body_size_limit=self.config.body_size_limit,
             include_body=False,
+            stream_id=self._stream_id
         )
-        response.stream_id = request.stream_id
-        return response
 
     def send_to_client(self, message):
         # TODO: implement flow control and WINDOW_UPDATE frames
@@ -356,7 +357,7 @@ class HttpLayer(Layer):
     def get_response_from_server(self, flow):
         def get_response():
             self.send_to_server(flow.request)
-            flow.response = self.read_from_server(flow.request)
+            flow.response = self.read_from_server(flow.request.method)
 
         try:
             get_response()

test/test_protocol_http.py

@@ -28,19 +28,19 @@ class TestHTTPResponse:
              "\r\n"
 
         protocol = mock_protocol(s)
-        r = HTTPResponse.from_protocol(protocol, netlib.http.EmptyRequest(method="GET"))
+        r = HTTPResponse.from_protocol(protocol, "GET")
         assert r.status_code == 200
         assert r.content == "content"
-        assert HTTPResponse.from_protocol(protocol, netlib.http.EmptyRequest(method="GET")).status_code == 204
+        assert HTTPResponse.from_protocol(protocol, "GET").status_code == 204
 
         protocol = mock_protocol(s)
         # HEAD must not have content by spec. We should leave it on the pipe.
-        r = HTTPResponse.from_protocol(protocol, netlib.http.EmptyRequest(method="HEAD"))
+        r = HTTPResponse.from_protocol(protocol, "HEAD")
         assert r.status_code == 200
         assert r.content == ""
         tutils.raises(
             "Invalid server response: 'content",
-            HTTPResponse.from_protocol, protocol, netlib.http.EmptyRequest(method="GET")
+            HTTPResponse.from_protocol, protocol, "GET"
         )
 
 

test/test_proxy.py

@@ -36,7 +36,7 @@ class TestServerConnection:
         sc.send(protocol.assemble(f.request))
 
         protocol = http.http1.HTTP1Protocol(rfile=sc.rfile)
-        assert protocol.read_response(f.request, 1000)
+        assert protocol.read_response(f.request.method, 1000)
         assert self.d.last_log()
 
         sc.finish()