stoobly-agent 0.21.0__py3-none-any.whl → 0.22.3__py3-none-any.whl

stoobly_agent/app/models/adapters/mitmproxy/response/python_adapter.py

@@ -0,0 +1,24 @@
+from io import BytesIO
+import requests
+
+from mitmproxy.http import Response as MitmproxyResponse
+from urllib3 import HTTPResponse
+
+class PythonResponseAdapter():
+
+  def __init__(self, response: MitmproxyResponse):
+    self.__response = response
+
+  def adapt(self) -> requests.Response:
+    response = requests.Response()
+    response.status_code = self.__response.status_code
+    response.headers = self.__response.headers
+
+    response.raw = HTTPResponse(
+      body=BytesIO(self.__response.raw_content),
+      decode_content=False,
+      headers=self.__response.headers,
+      preload_content=False
+    )
+
+    return response

stoobly_agent/app/models/adapters/python/__init__.py

@@ -0,0 +1,2 @@
+from .request import PythonRequestAdapterFactory
+from .response import PythonResponseAdapterFactory

stoobly_agent/app/models/adapters/python/request/__init__.py

@@ -0,0 +1,18 @@
+import pdb
+import requests
+
+from urllib.parse import parse_qs, urlparse
+
+from .mitmproxy_adapter import MitmproxyRequestAdapter
+from .stoobly_adapter import StooblyRequestAdapter
+
+class PythonRequestAdapterFactory():
+
+  def __init__(self, request: requests.Request):
+    self.__request = request
+
+  def mitmproxy_request(self, http_version: str = 'HTTP/1.1'):
+    return MitmproxyRequestAdapter(http_version, self.__request).adapt()
+
+  def stoobly_request(self):
+    return StooblyRequestAdapter(self.__request).adapt()

stoobly_agent/app/models/adapters/python/request/mitmproxy_adapter.py

@@ -0,0 +1,53 @@
+import pdb
+import requests
+
+from mitmproxy.http import Headers, Request as MitmproxyRequest
+from urllib.parse import urlparse
+
+class MitmproxyRequestAdapter():
+
+  def __init__(self, http_version, request: requests.Request):
+    self.__http_version = http_version
+    self.__request = request
+
+  @property
+  def url(self):
+    parsed_url = urlparse(self.__request.url)
+
+    if not parsed_url.netloc:
+      parsed_url = parsed_url._replace(netloc=parsed_url.path, path='')
+
+    if not parsed_url.scheme:
+      parsed_url = parsed_url._replace(scheme='https')
+
+    return parsed_url.geturl()
+
+  @property
+  def headers(self):
+    return Headers(**self.__decode_dict(self.__request.headers))
+
+  @property
+  def data(self):
+    _data = self.__request.data
+
+    # If no data is provided to python requests.Request, it is sent to []
+    if _data == []:
+      return b''
+
+    return _data
+
+  def adapt(self):
+    request = MitmproxyRequest.make(
+      self.__request.method,
+      self.url,
+      self.data,
+      self.headers,
+    )
+    request.http_version = self.__http_version
+    return request
+
+  def __decode_dict(self, d):
+    new_d = {}
+    for k, v in d.items():
+      new_d[k.decode() if isinstance(k, bytes) else k] = v.decode() if isinstance(v, bytes) else v
+    return new_d

stoobly_agent/app/models/adapters/python/request/stoobly_adapter.py

@@ -0,0 +1,49 @@
+import pdb
+import requests
+
+from urllib.parse import parse_qs, urlparse
+
+class StooblyRequestAdapter():
+
+  def __init__(self, request: requests.Request):
+    self.__request = request
+
+  def adapt(self):
+    parsed_url = urlparse(self.__request.url)
+
+    return {
+      'body': self.__request.data,
+      'headers': self.adapt_headers(),
+      'method': self.__request.method,
+      'path': parsed_url.path,
+      'query_params': self.adapt_query_params(parsed_url.query),
+      'url': self.__request.url,
+    }
+
+  def adapt_query_params(self, query = None):
+    if not query:
+      parsed_url = urlparse(self.__request.url)
+      query = parsed_url.query
+
+    _query_params = parse_qs(query)
+
+    query_params = []
+    for k, v in _query_params.items():
+      for param in v:
+        query_params.append({
+          'name': k,
+          'value': param,
+        })
+
+    return query_params
+
+  def adapt_headers(self):
+    headers = []
+
+    for k, v in self.__request.headers.items():
+      headers.append({
+        'name': k,
+        'value': v
+      })
+
+    return headers

stoobly_agent/app/models/adapters/python/response/__init__.py

@@ -0,0 +1,13 @@
+import http
+import pdb
+import requests
+
+from .mitmproxy_adapter import MitmproxyResponseAdapter
+
+class PythonResponseAdapterFactory():
+
+  def __init__(self, response: requests.Response):
+    self.__response = response
+
+  def mitmproxy_response(self):
+    return MitmproxyResponseAdapter(self.__response).adapt()

stoobly_agent/app/models/adapters/{mitmproxy_response_adapter.py → python/response/mitmproxy_adapter.py}

@@ -1,13 +1,21 @@
-from time import time
+import pdb
 import requests
 
 from mitmproxy.http import Headers, Response as MitmproxyResponse
+from time import time
+
+from stoobly_agent.app.models.adapters.raw_http_request_adapter import DEFAULT_HTTP_VERSION
 
 class MitmproxyResponseAdapter():
 
-  def __init__(self, http_version, response: requests.Response):
+  def __init__(self, response: requests.Response):
     self.__timestamp_start = time()
-    self.__http_version = http_version
+
+    if hasattr(response, 'raw'):
+      self.__http_version = f"HTTP/{response.raw.version / 10.0}"
+    else:
+      self.__http_version = DEFAULT_HTTP_VERSION
+
     self.__latency = 0 # Seconds
     self.__response = response
  
@@ -41,11 +49,11 @@ class MitmproxyResponseAdapter():
 
   def adapt(self):
     body = b''
-
-    try:
-      body = self.__response.raw.data
-    except:
+    
+    if self.__response._content_consumed or not hasattr(self.__response, 'raw'):
       body = self.__response.content
+    else:
+      body = self.__response.raw.data
 
     return MitmproxyResponse(
       self.__http_version,

stoobly_agent/app/models/adapters/raw_http_request_adapter.py

@@ -1,5 +1,8 @@
+import pdb
 import requests
 
+from typing import Union
+
 CRLF = b'\r\n'
 DEFAULT_HTTP_VERSION = b'HTTP/1.1'
 
@@ -14,29 +17,33 @@ class RawHttpRequestAdapter():
         colon_ind = req_lines[ind].find(b':')
         header_key = req_lines[ind][:colon_ind]
         header_value = req_lines[ind][colon_ind + 1:]
-        self.headers[header_key] = header_value
+        self.headers[self.__decode(header_key)] = self.__decode(header_value).strip()
         ind += 1
     ind += 1
     data_lines = req_lines[ind:] if ind < len(req_lines) else None
     self.body = CRLF.join(data_lines)
 
+  def to_request(self):
+    req = requests.Request(
+      method=self.method,
+      url=self.url,
+      headers=self.headers,
+      data=self.body
+    )
+
+    return req
+
   def __parse_request_line(self, request_line):
     request_parts = request_line.split(b' ')
-    self.method = request_parts[0]
-    self.url = request_parts[1]
-    self.protocol = request_parts[2] if len(request_parts) > 2 else DEFAULT_HTTP_VERSION
+    self.method = self.__decode(request_parts[0])
+    self.url = self.__decode(request_parts[1])
+    self.protocol = self.__decode(request_parts[2]) if len(request_parts) > 2 else DEFAULT_HTTP_VERSION
 
   def __str__(self):
     headers = CRLF.join(f'{key}: {self.headers[key]}' for key in self.headers)
     return f'{self.method} {self.url} {self.protocol}{CRLF}' \
             f'{headers}{CRLF}{CRLF}{self.body}'
 
-  def to_request(self):
-    req = requests.Request(
-      method=self.method,
-      url=self.url,
-      headers=self.headers,
-      data=self.body
-    )
 
-    return req
+  def __decode(self, s: Union[bytes, str]) -> str:
+    return s if isinstance(s, str) else s.decode()

stoobly_agent/app/models/adapters/raw_http_response_adapter.py

@@ -6,6 +6,7 @@ from io import BytesIO
 from mitmproxy.net import encoding
 from requests.structures import CaseInsensitiveDict
 from typing import Union
+from urllib3 import HTTPResponse
 
 from stoobly_agent.app.proxy.mitmproxy.response import Response
 from stoobly_agent.lib.orm.utils.response_parse_handler import Response as ResponseDict, ResponseParseHandler
@@ -17,28 +18,36 @@ class RawHttpResponseAdapter():
 
   def __init__(self, req_text):
     self.__req_text = req_text
-
-  def to_response(self):
     req_lines = self.__req_text.split(CRLF)
+
     self.__parse_response_line(req_lines[0])
+
     ind = 1
-    headers = CaseInsensitiveDict()
+    self.headers = CaseInsensitiveDict()
     while ind < len(req_lines) and len(req_lines[ind]) > 0:
         colon_ind = req_lines[ind].find(b':')
         header_key = req_lines[ind][:colon_ind]
         header_value = req_lines[ind][colon_ind + 1:]
-        headers[self.__decode(header_key)] = self.__decode(header_value).strip()
+        self.headers[self.__decode(header_key)] = self.__decode(header_value).strip()
         ind += 1
     ind += 1
+
     data_lines = req_lines[ind:] if ind < len(req_lines) else None
+    self.body = CRLF.join(data_lines)
 
+  def to_response(self):
     response = requests.Response()
     response.status_code = self.status
-    response.headers = headers
+    response.headers = self.headers
+
+    response.raw = HTTPResponse(
+      body=BytesIO(self.body),
+      decode_content=False,
+      headers=self.headers,
+      preload_content=False
+    )
 
-    content_encoding = response.headers.get('content-encoding')
-    body = CRLF.join(data_lines)
-    response.raw = self.__decode_body(body, content_encoding)
+    #response.raw = self.__decode_body(self.body, content_encoding)
 
     return response
 
@@ -67,12 +76,13 @@ class RawHttpResponseAdapter():
 
   def __parse_response_line(self, response_line):
     response_parts = response_line.split(b' ')
-    self.protocol = response_parts[0] if len(response_parts) > 2 else DEFAULT_HTTP_VERSION
-    self.status = response_parts[1]
+    self.protocol = self.__decode(response_parts[0]) if len(response_parts) > 2 else DEFAULT_HTTP_VERSION
+    self.status = int(self.__decode(response_parts[1]))
+    self.reason = self.__decode(response_parts[2]) if len(response_parts) > 2 else ''
 
   def __str__(self):
     headers = CRLF.join(f'{key}: {self.headers[key]}' for key in self.headers)
-    return f'{self.method} {self.url} {self.protocol}{CRLF}' \
+    return f'{self.protocol} {self.status} {self.reason}{CRLF}' \
             f'{headers}{CRLF}{CRLF}{self.body}'
 
   def __new_parser(self, response_dict):
@@ -81,7 +91,7 @@ class RawHttpResponseAdapter():
     parser.feed_data(memoryview(self.__req_text))
     return parser
 
-  def __decode(self, s: Union[bytes, str]):
+  def __decode(self, s: Union[bytes, str]) -> str:
     return s if isinstance(s, str) else s.decode()
 
   def __decode_body(self, body: bytes, content_encoding):

stoobly_agent/app/models/adapters/stoobly/request/__init__.py

@@ -0,0 +1,11 @@
+from lib.api.interfaces.requests import RequestShowResponse
+
+from .mitmproxy_adapter import MitmproxyRequestAdapter
+
+class StooblyRequestAdapterFactory():
+
+  def __init__(self, request: RequestShowResponse):
+    self.__request = request
+
+  def mitmproxy_request(self):
+    return MitmproxyRequestAdapter(self.__request)

stoobly_agent/app/models/adapters/stoobly/request/mitmproxy_adapter.py

@@ -0,0 +1,32 @@
+import pdb
+import requests
+
+from mitmproxy.http import Headers, Request as MitmproxyRequest
+
+from stoobly_agent.app.models.schemas.request import Request
+
+class MitmproxyRequestAdapter():
+
+  def __init__(self, request: Request):
+    self.__http_version = 'HTTP/1.1'
+    self.__request = request
+
+  @property
+  def headers(self):
+    return Headers(**self.__decode_dict(self.__request.headers))
+
+  def adapt(self):
+    request = MitmproxyRequest.make(
+      self.__request.method,
+      self.__request.url,
+      self.__request.body,
+      self.headers,
+    )
+    request.http_version = self.__http_version
+    return request
+
+  def __decode_dict(self, d):
+    new_d = {}
+    for k, v in d.items():
+      new_d[k.decode() if isinstance(k, bytes) else k] = v.decode() if isinstance(v, bytes) else v
+    return new_d

stoobly_agent/app/models/body_model.py

@@ -1,10 +1,10 @@
 import pdb
 import requests
 
-from stoobly_agent.app.models.adapters.body_adapter_factory import BodyAdapterFactory
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.lib.logger import Logger
 
+from .factories.resource.body import BodyResourceFactory
 from .model import Model
 
 class BodyModel(Model):
@@ -13,7 +13,7 @@ class BodyModel(Model):
     super().__init__(settings)
 
   def as_local(self):
-    self.adapter = BodyAdapterFactory(self.settings.remote).local_db()
+    self.adapter = BodyResourceFactory(self.settings.remote).local_db()
 
   def as_remote(self):
     # 'Not yet supported.'

stoobly_agent/app/models/{adapters/body_adapter_factory.py → factories/resource/body.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.request import Request
 
 from .local_db.body_adapter import LocalDBBodyAdapter
 
-class BodyAdapterFactory():
+class BodyResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/header_adapter_factory.py → factories/resource/header.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.request import Request
 
 from .local_db.header_adapter import LocalDBHeaderAdapter
 
-class HeaderAdapterFactory():
+class HeaderResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters → factories/resource}/local_db/header_adapter.py

@@ -24,8 +24,8 @@ class LocalDBHeaderAdapter():
     headers = []
     for key, val in request.headers.items():
       headers.append({
-        'name': key.decode(),
-        'value': val.decode(),
+        'name': key,
+        'value': val,
       })
 
     return headers

stoobly_agent/app/models/{adapters → factories/resource}/local_db/replayed_response_adapter.py

@@ -1,14 +1,13 @@
 import pdb
 import requests
 
+from stoobly_agent.app.models.types import ReplayedResponseIndexQueryParams
 from stoobly_agent.lib.api.interfaces.requests import RequestShowResponse
 from stoobly_agent.lib.orm.replayed_response import ReplayedResponse
 from stoobly_agent.lib.orm.transformers.orm_to_requests_response_transformer import ORMToRequestsResponseTransformer
 from stoobly_agent.lib.orm.transformers.orm_to_stoobly_request_transformer import ORMToStooblyRequestTransformer
 from stoobly_agent.lib.orm.utils.response_parse_handler import Response
 
-from ..types.replayed_response import ReplayedResponseIndexQueryParams
-
 class LocalDBReplayedResponseAdapter():
   __replayed_response_orm = None
 

stoobly_agent/app/models/{adapters → factories/resource}/local_db/request_adapter.py

@@ -3,13 +3,12 @@ from urllib.parse import urlparse
 import requests
 
 from mitmproxy.http import HTTPFlow as MitmproxyHTTPFlow, Request as MitmproxyRequest
-from typing import List
 
+from stoobly_agent.app.models.types import RequestCreateParams, RequestShowParams
 from stoobly_agent.app.proxy.mock.custom_not_found_response_builder import CustomNotFoundResponseBuilder
 from stoobly_agent.app.proxy.mock.hashed_request_decorator import HashedRequestDecorator
 from stoobly_agent.app.proxy.mitmproxy.request_facade import MitmproxyRequestFacade
 from stoobly_agent.app.proxy.upload.joined_request import JoinedRequest
-
 from stoobly_agent.lib.orm import ORM
 from stoobly_agent.lib.orm.request import Request
 from stoobly_agent.lib.orm.response import Response
@@ -19,8 +18,6 @@ from stoobly_agent.lib.orm.types.response_columns import ResponseColumns
 from stoobly_agent.lib.orm.transformers import ORMToRequestsResponseTransformer, ORMToStooblyResponseTransformer
 from stoobly_agent.lib.api.interfaces import RequestsIndexQueryParams, RequestsIndexResponse, RequestShowResponse
 
-from ..types import RequestCreateParams, RequestShowParams
-
 class LocalDBRequestAdapter():
   __request_orm = None
   __response_orm = None
@@ -73,14 +70,23 @@ class LocalDBRequestAdapter():
   def show(self, request_id: str, **options: RequestShowParams) -> RequestShowResponse:
     request = self.__request_orm.find(request_id)
 
+    if not request:
+      return CustomNotFoundResponseBuilder().build()
+
     return ORMToStooblyRequestTransformer(request, options).transform()
 
   def response(self, **query_params: RequestColumns) -> requests.Response:
-    request_columns = { **query_params }
-    self.__filter_request_response_columns(request_columns)
+    request = None
+
+    if not query_params.get('request_id'):
+      request_columns = { **query_params }
 
-    # Find most recent matching record
-    request = self.__request_orm.where_for(**request_columns).get().last()
+      self.__filter_request_response_columns(request_columns)
+
+      # Find most recent matching record
+      request = self.__request_orm.where_for(**request_columns).get().last()
+    else:
+      request = self.__request_orm.find(query_params.get('request_id'))
 
     if not request:
       return CustomNotFoundResponseBuilder().build()
@@ -107,6 +113,7 @@ class LocalDBRequestAdapter():
 
     if scenario_id: 
       requests = requests.where('scenario_id', int(scenario_id))
+      sort_order = query_params.get('sort_order') or 'asc' 
 
     if starred:
       requests = requests.where('starred', starred)

stoobly_agent/app/models/{adapters → factories/resource}/local_db/scenario_adapter.py

@@ -1,13 +1,11 @@
 import pdb
 
-from stoobly_agent.app.models.adapters.types.scenario_create_params import ScenarioCreateParams
+from stoobly_agent.app.models.types import ScenarioCreateParams
 from stoobly_agent.lib.api.interfaces import ScenariosIndexQueryParams, ScenariosIndexResponse, ScenarioShowResponse
 from stoobly_agent.lib.api.keys.scenario_key import ScenarioKey
 from stoobly_agent.lib.orm import ORM
 from stoobly_agent.lib.orm.scenario import Scenario
 
-from ..types import ScenarioCreateParams
-
 class LocalDBScenarioAdapter():
   __scenario_orm = None
 
@@ -30,13 +28,21 @@ class LocalDBScenarioAdapter():
     sort_by = query_params.get('sort_by') or 'id'
     sort_order = query_params.get('sort_order') or 'desc'
 
-    is_deleted = query_params.get('filter') == 'is_deleted'
-    starred = query_params.get('filter') == 'starred'
+    filter = query_params.get('filter')
+    is_deleted = filter == 'is_deleted'
 
     scenarios = Scenario.where('is_deleted', is_deleted)
 
-    if starred:
-      scenarios = scenarios.where('starred', starred)
+    if filter == 'starred':
+      scenarios = scenarios.where('starred', True)
+    elif filter == 'high_priority':
+      scenarios = scenarios.where('priority', 3)
+    elif filter == 'medium_priority':
+      scenarios = scenarios.where('priority', 2)
+    elif filter == 'low_priority':
+      scenarios = scenarios.where('priority', 1)
+    elif filter == 'none_priority':
+      scenarios = scenarios.where('priority', 0)
 
     if query:
       scenarios = self.__search(scenarios, query)

stoobly_agent/app/models/{adapters/query_param_adapter_factory.py → factories/resource/query_param.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.request import Request
 
 from .local_db.query_param_adapter import LocalDBQueryParamAdapter
 
-class QueryParamAdapterFactory():
+class QueryParamResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/replayed_response_adapter_factory.py → factories/resource/replayed_response.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.replayed_response import ReplayedResponse
 
 from .local_db.replayed_response_adapter import LocalDBReplayedResponseAdapter
 
-class ReplayedResponseAdapterFactory():
+class ReplayedResponseResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/request_adapter_factory.py → factories/resource/request.py}

@@ -3,9 +3,9 @@ from stoobly_agent.lib.api.requests_resource import RequestsResource
 from stoobly_agent.app.settings import RemoteSettings
 
 from .local_db.request_adapter import LocalDBRequestAdapter
-from .stoobly_request_adapter import StooblyRequestAdapter
+from .stoobly.request_adapter import StooblyRequestAdapter
 
-class RequestAdapterFactory():
+class RequestResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/response_adapter_factory.py → factories/resource/response.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.request import Request
 
 from .local_db.response_adapter import LocalDBResponseAdapter
 
-class ResponseAdapterFactory():
+class ResponseResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/response_header_adapter_factory.py → factories/resource/response_header.py}

@@ -3,7 +3,7 @@ from stoobly_agent.lib.orm.request import Request
 
 from .local_db.response_header_adapter import LocalDBResponseHeaderAdapter
 
-class ResponseHeaderAdapterFactory():
+class ResponseHeaderResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/scenario_adapter_factory.py → factories/resource/scenario.py}

@@ -3,9 +3,9 @@ from stoobly_agent.lib.api.scenarios_resource import ScenariosResource
 from stoobly_agent.app.settings import RemoteSettings
 
 from .local_db.scenario_adapter import LocalDBScenarioAdapter
-from .stoobly_scenario_adapter import StooblyScenarioAdapter
+from .stoobly.scenario_adapter import StooblyScenarioAdapter
 
-class ScenarioAdapterFactory():
+class ScenarioResourceFactory():
 
   def __init__(self, settings: RemoteSettings):
     self.__remote_settings = settings

stoobly_agent/app/models/{adapters/stoobly_request_adapter.py → factories/resource/stoobly/request_adapter.py}

@@ -1,11 +1,10 @@
 import pdb
 import requests
 
+from stoobly_agent.app.models.types import RequestCreateParams, RequestShowParams
 from stoobly_agent.lib.api.requests_resource import RequestsResource
 from stoobly_agent.lib.api.interfaces import RequestShowResponse, RequestsIndexResponse
 
-from .types import RequestCreateParams, RequestShowParams
-
 class StooblyRequestAdapter():
 
   def __init__(self, __api: RequestsResource):

stoobly_agent/app/models/{adapters/stoobly_scenario_adapter.py → factories/resource/stoobly/scenario_adapter.py}

@@ -1,10 +1,9 @@
 import pdb
 
+from stoobly_agent.app.models.types import ScenarioCreateParams
 from stoobly_agent.lib.api.scenarios_resource import ScenariosResource
 from stoobly_agent.lib.api.interfaces.scenarios import ScenarioShowResponse, ScenariosIndexResponse
 
-from .types import ScenarioCreateParams
-
 class StooblyScenarioAdapter():
 
   def __init__(self, __api: ScenariosResource):