har entry data scope fix

Author: kiturutin

browserup-proxy-core/src/main/resources/mitmproxy/har_dump.py

@@ -513,7 +513,7 @@ def populate_har_entry_with_default_response(self, flow):
 
         ctx.log.debug('Creating new har entry for request: {}'.format(full_url))
 
-        har_entry = flow.server_conn.currentHarEntry
+        har_entry = flow.metadata['har_entry']
 
         har_entry['pageref'] = self.get_current_page_ref()
         har_entry['startedDateTime'] = datetime.fromtimestamp(flow.request.timestamp_start, timezone.utc).isoformat()
@@ -555,7 +555,7 @@ def request(self, flow):
         if HarCaptureTypes.RESPONSE_CONTENT in self.har_capture_types:
             self.capture_request_content(flow)
 
-        har_entry = flow.server_conn.currentHarEntry
+        har_entry = flow.metadata['har_entry']
         har_entry['request']['bodySize'] = \
             len(flow.request.raw_content) if flow.request.raw_content else 0
 
@@ -589,7 +589,7 @@ def capture_request_content(self, flow):
         }
 
     def response(self, flow):
-        har_entry = flow.server_conn.currentHarEntry
+        har_entry = flow.metadata['har_entry']
 
         ctx.log.debug('Incoming response for request to url: {}'.format(flow.request.url))
 

browserup-proxy-core/src/main/resources/mitmproxy/http_connect_capture.py

@@ -55,10 +55,10 @@ def generate_http_connect_timing(self):
 
     # TCP Callbacks
 
-    def tcp_resolving_server_address_finished(self, server_conn):
-        if not hasattr(server_conn, 'currentHarEntry'):
+    def tcp_resolving_server_address_finished(self, flow):
+        if 'har_entry' not in flow.metadata:
             return
-        self.populate_dns_timings(server_conn)
+        self.populate_dns_timings(flow)
         self.dns_resolution_finished_nanos = self.now_time_nanos()
 
         if self.dns_resolution_started_nanos > 0:
@@ -67,7 +67,7 @@ def tcp_resolving_server_address_finished(self, server_conn):
         else:
             self.get_http_connect_timing()['dnsTimeNanos'] = 0
 
-    def tcp_resolving_server_address_started(self, server_conn):
+    def tcp_resolving_server_address_started(self, flow):
         self.dns_resolution_started_nanos = int(round(self.now_time_nanos()))
         self.connection_started_nanos = int(round(self.now_time_nanos()))
         self.proxy_to_server_resolution_started()
@@ -89,10 +89,10 @@ def http_proxy_to_server_request_started(self, flow):
     def http_proxy_to_server_request_finished(self, flow):
         self.send_finished_nanos = self.now_time_nanos()
         if self.send_started_nanos > 0:
-            self.get_har_entry(flow.server_conn)['timings'][
+            self.get_har_entry(flow)['timings'][
                 'send'] = self.send_finished_nanos - self.send_started_nanos
         else:
-            self.get_har_entry(flow.server_conn)['timings']['send'] = 0
+            self.get_har_entry(flow)['timings']['send'] = 0
 
     def http_server_to_proxy_response_receiving(self, flow):
         self.response_receive_started_nanos = self.now_time_nanos()
@@ -136,23 +136,23 @@ def error(self, flow):
 
     # Populate data
 
-    def populate_dns_timings(self, server_conn):
-        har_entry = self.get_har_entry(server_conn)
+    def populate_dns_timings(self, flow):
+        har_entry = self.get_har_entry(flow)
         if self.dns_resolution_started_nanos > 0 and har_entry:
             time_now = self.now_time_nanos()
             dns_nanos = time_now - self.dns_resolution_started_nanos
             har_entry['timings']['dnsNanos'] = dns_nanos
 
     def populate_timings_for_failed_connect(self, flow):
-        har_entry = self.get_har_entry(flow.server_conn)
+        har_entry = self.get_har_entry(flow)
         if self.connection_started_nanos > 0:
             connect_nanos = self.now_time_nanos() - self.connection_started_nanos
             har_entry['timings']['connectNanos'] = connect_nanos
-        self.populate_dns_timings(flow.server_conn)
+        self.populate_dns_timings(flow)
 
     def populate_server_ip_address(self, flow, original_error):
         if flow.server_conn is not None and flow.server_conn.ip_address is not None:
-            self.get_har_entry(flow.server_conn)['serverIPAddress'] = str(
+            self.get_har_entry(flow)['serverIPAddress'] = str(
                 flow.server_conn.ip_address[0])
 
     def get_resource(self):
@@ -161,18 +161,18 @@ def get_resource(self):
     def proxy_to_server_resolution_failed(self, flow, req_host_port, original_error):
         msg = RESOLUTION_FAILED_ERROR_MESSAGE + req_host_port
         self.create_har_entry_for_failed_connect(flow, msg)
-        self.populate_dns_timings(flow.server_conn)
+        self.populate_dns_timings(flow)
         self.populate_server_ip_address(flow, original_error)
 
-        self.get_har_entry(flow.server_conn)['time'] = self.calculate_total_elapsed_time(flow)
+        self.get_har_entry(flow)['time'] = self.calculate_total_elapsed_time(flow)
 
     def proxy_to_server_connection_failed(self, flow, original_error):
         msg = CONNECTION_FAILED_ERROR_MESSAGE
         self.create_har_entry_for_failed_connect(flow, msg)
         self.populate_timings_for_failed_connect(flow)
         self.populate_server_ip_address(flow, original_error)
 
-        self.get_har_entry(flow.server_conn)['time'] = self.calculate_total_elapsed_time(flow)
+        self.get_har_entry(flow)['time'] = self.calculate_total_elapsed_time(flow)
 
     def server_to_proxy_response_timed_out(self, flow, req_host_port, original_error):
         msg = RESPONSE_TIMED_OUT_ERROR_MESSAGE
@@ -182,7 +182,7 @@ def server_to_proxy_response_timed_out(self, flow, req_host_port, original_error
 
         current_time_nanos = self.now_time_nanos()
 
-        har_entry = self.get_har_entry(flow.server_conn)
+        har_entry = self.get_har_entry(flow)
 
         if self.send_started_nanos > 0 and self.send_finished_nanos == 0:
             har_entry['timings']['sendNanos'] = current_time_nanos - self.send_started_nanos
@@ -196,11 +196,11 @@ def server_to_proxy_response_timed_out(self, flow, req_host_port, original_error
         har_entry['time'] = self.calculate_total_elapsed_time(flow)
 
     def create_har_entry_for_failed_connect(self, flow, msg):
-        har_entry = self.get_har_entry(flow.server_conn)
+        har_entry = self.get_har_entry(flow)
         har_entry['response']['_errorMessage'] = msg
 
     def calculate_total_elapsed_time(self, flow):
-        timings = self.get_har_entry(flow.server_conn)['timings']
+        timings = self.get_har_entry(flow)['timings']
         result = (0 if timings.get('blockedNanos', -1) == -1 else timings['blockedNanos']) + \
                  (0 if timings.get('dnsNanos', -1) == -1 else timings['dnsNanos']) + \
                  (0 if timings.get('connectNanos', -1) == -1 else timings['connectNanos']) + \
@@ -209,8 +209,8 @@ def calculate_total_elapsed_time(self, flow):
                  (0 if timings.get('receiveNanos', -1) == -1 else timings['receiveNanos'])
         return self.nano_to_ms(result)
 
-    def get_har_entry(self, server_conn):
-        return server_conn.currentHarEntry
+    def get_har_entry(self, flow):
+        return flow.metadata['har_entry']
 
     def get_http_connect_timing(self):
         if self.http_connect_timing is None:

browserup-proxy-core/src/main/resources/mitmproxy/init_flow.py

@@ -45,16 +45,16 @@ def get_resource(self):
         return InitFlowResource(self)
 
     def http_connect(self, flow):
-        if not hasattr(flow.server_conn, 'currentHarEntry'):
+        if 'har_entry' not in flow.metadata:
             self.init_har_entry(flow)
 
     def request(self, flow):
-        if not hasattr(flow.server_conn, 'currentHarEntry'):
+        if 'har_entry' not in flow.metadata:
             self.init_har_entry(flow)
 
     def init_har_entry(self, flow):
-        setattr(flow.server_conn, 'currentHarEntry', self.har_dump_addon.generate_har_entry())
-        self.har_dump_addon.append_har_entry(flow.server_conn.currentHarEntry)
+        flow.metadata['har_entry'] = self.har_dump_addon.generate_har_entry()
+        self.har_dump_addon.append_har_entry(flow.metadata['har_entry'])
 
 addons = [
     InitFlowAddOn()

browserup-proxy-core/src/test/groovy/com/browserup/bup/mitmproxy/NewHarTest.groovy

@@ -22,9 +22,11 @@ import org.junit.Test
 import java.text.SimpleDateFormat
 import java.util.concurrent.TimeUnit
 
+import static com.browserup.bup.mitmproxy.MitmProxyProcessManager.MitmProxyLoggingLevel.*
 import static com.github.tomakehurst.wiremock.client.WireMock.*
 import static org.hamcrest.Matchers.*
 import static org.junit.Assert.*
+import static org.mockito.ArgumentMatchers.eq
 import static org.mockito.Mockito.mock
 import static org.mockito.Mockito.when
 
@@ -118,9 +120,9 @@ class NewHarTest extends MockServerTest {
         )
 
         proxy = new MitmProxyServer()
-        proxy.setHarCaptureTypes([CaptureType.RESPONSE_COOKIES] as Set)
         proxy.setTrustAllServers(true)
         proxy.start()
+        proxy.setHarCaptureTypes([CaptureType.RESPONSE_COOKIES] as Set)
 
         proxy.newHar()
 
@@ -138,7 +140,7 @@ class NewHarTest extends MockServerTest {
         Thread.sleep(500)
         Har har = proxy.getHar()
 
-        assertThat("Expected to find entries in the HAR", har.getLog().getEntries(), not(empty()))
+        assertThat("Expected one HAR entry", har.getLog().getEntries(), hasSize(1))
         assertThat("Expected to find two cookies in the HAR", har.getLog().getEntries().first().response.cookies, hasSize(2))
 
         HarCookie maxAgeCookie = har.getLog().getEntries().first().response.cookies[0]