stoobly-agent 1.10.2__py3-none-any.whl → 1.10.4__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '1.10.2'
+VERSION = '1.10.4'

stoobly_agent/app/api/application_http_request_handler.py

@@ -134,7 +134,7 @@ class ApplicationHTTPRequestHandler(SimpleHTTPRequestHandler):
         for endpoint_handler in ROUTES[method]:
             path = endpoint_handler[0]
 
-            matches = self.path == path if isinstance(path, str) else bool(re.match(path, self.path))
+            matches = self.path == path if isinstance(path, str) else bool(re.fullmatch(path, self.path))
 
             if matches:
                 handler = endpoint_handler[1]

stoobly_agent/app/cli/helpers/validations.py

@@ -126,7 +126,7 @@ def validate_aliases(validations, **kwargs) -> Union[Alias, None]:
       handle_missing_alias(parsed_validation, kwargs.get('format'))
 
     if parsed_validation['value'] != None:
-      if not re.match(parsed_validation['value'], aliases_map[name]):
+      if not re.fullmatch(parsed_validation['value'], aliases_map[name]):
         handle_invalid_alias(parsed_validation, aliases_map[name], kwargs.get('format'))
 
 def filter_response(res, status: int):

stoobly_agent/app/cli/scaffold/app.py

@@ -111,7 +111,7 @@ class App():
 
               # Skip files that match the ignore list pattern, use regex
               for ignore_pattern in ignore:
-                  if re.match(os.path.join(src, ignore_pattern), src_file_path):
+                  if re.fullmatch(os.path.join(src, ignore_pattern), src_file_path):
                       ignored = True
                       break
 

stoobly_agent/app/cli/scaffold/app_create_command.py

@@ -12,7 +12,7 @@ from .app import App
 from .app_command import AppCommand
 from .constants import PLUGIN_CYPRESS, PLUGIN_PLAYWRIGHT, RUN_ON_DOCKER, RUN_ON_LOCAL
 from .docker.template_files import plugin_docker_cypress, plugin_docker_playwright, plugin_local_cypress, plugin_local_playwright, remove_app_docker_files, remove_service_docker_files
-from .templates.constants import CORE_GATEWAY_SERVICE_NAME, CORE_MOCK_UI_SERVICE_NAME, MAINTAINED_RUN
+from .templates.constants import CORE_GATEWAY_SERVICE_NAME, CORE_MOCK_UI_SERVICE_NAME, CUSTOM_RUN, MAINTAINED_RUN
 
 class AppCreateOptions(TypedDict):
   docker_socket_path: str
@@ -85,6 +85,7 @@ class AppCreateCommand(AppCommand):
             ignore.append(f"{CORE_MOCK_UI_SERVICE_NAME}/.*")
 
         if RUN_ON_DOCKER in self.app_run_on:
+            ignore.append(f".*/{CUSTOM_RUN}")
             ignore.append(f".*/{MAINTAINED_RUN}")
 
         # Copy all app templates

stoobly_agent/app/cli/scaffold/docker/workflow/run_command.py

@@ -2,12 +2,14 @@ import os
 import pdb
 import subprocess
 import sys
+import time
 
 from typing import List
+from types import FunctionType
 
 from stoobly_agent.app.cli.scaffold.docker.constants import APP_EGRESS_NETWORK_TEMPLATE, APP_INGRESS_NETWORK_TEMPLATE, DOCKERFILE_CONTEXT
 from stoobly_agent.app.cli.scaffold.docker.service.configure_gateway import configure_gateway
-from stoobly_agent.app.cli.scaffold.templates.constants import CORE_ENTRYPOINT_SERVICE_NAME
+from stoobly_agent.app.cli.scaffold.templates.constants import CORE_ENTRYPOINT_SERVICE_NAME, CORE_SERVICES
 from stoobly_agent.app.cli.scaffold.workflow import Workflow
 from stoobly_agent.app.cli.scaffold.workflow_run_command import WorkflowRunCommand
 from stoobly_agent.app.cli.types.workflow_run_command import BuildOptions, DownOptions, UpOptions, WorkflowDownOptions, WorkflowUpOptions, WorkflowLogsOptions
@@ -27,10 +29,14 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
     self.services = services or []
     self.script = script
 
+  @property
+  def timestamp_file_extension(self):
+    return '.timestamp'
+
   @property
   def timestamp_file_path(self):
     """Get the path to the timestamp file for this workflow."""
-    return os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.timestamp")
+    return os.path.join(self.workflow_namespace.path, self.timestamp_file_name(self.workflow_name))
 
   def exec_setup(self, containerized=False, user_id=None, verbose=False):
     """Setup Docker environment including gateway, images, and networks."""
@@ -47,25 +53,34 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
     
     for command in init_commands:
       self.exec(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    
-  def up(self, **options: WorkflowUpOptions):
-    """Execute the complete Docker workflow up process."""
-    # Define timestamp file path
-    timestamp_file = self.timestamp_file_path
-    
+
+  def timestamp_file_name(self, workflow_name: str):
+    return f"{workflow_name}{self.timestamp_file_extension}"
+
+  def __create_timestamp_file(self):
     # Create timestamp file to indicate workflow is starting
+    timestamp_file = self.timestamp_file_path
+
     try:
       with open(timestamp_file, 'w') as f:
-        import time
         f.write(str(time.time()))
-      Logger.instance(LOG_ID).info(f"Created timestamp file: {timestamp_file}")
+      Logger.instance(LOG_ID).debug(f"Created timestamp file: {timestamp_file}")
     except Exception as e:
       Logger.instance(LOG_ID).error(f"Failed to create timestamp file: {e}")
       sys.exit(1)
     
+    return timestamp_file
+
+  def up(self, **options: WorkflowUpOptions):
+    """Execute the complete Docker workflow up process."""
+
     no_publish = options.get('no_publish', False)
     print_service_header = options.get('print_service_header')
-    
+
+    self.__iterate_active_workflows(handle_active=self.__handle_up_active)
+
+    timestamp_file = self.__create_timestamp_file()
+
     try:
       # Create individual service commands
       commands: List[DockerWorkflowRunCommand] = []
@@ -128,11 +143,7 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
 
   def down(self, **options: WorkflowDownOptions):
     """Execute the complete Docker workflow down process."""
-    # Check if workflow is running (timestamp file exists)
-    timestamp_file = self.timestamp_file_path
-    if not os.path.exists(timestamp_file):
-      Logger.instance(LOG_ID).info(f"Workflow '{self.workflow_name}' is not running. No timestamp file found: {timestamp_file}")
-      return
+    timestamp_file = self.__find_and_verify_timestamp_file()
     
     print_service_header = options.get('print_service_header')
     
@@ -188,7 +199,6 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
         self.exec(remove_ingress_network_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     
     # Clean up timestamp file
-    timestamp_file = os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.timestamp")
     if os.path.exists(timestamp_file):
       try:
         os.remove(timestamp_file)
@@ -197,14 +207,8 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
 
   def logs(self, **options: WorkflowLogsOptions):
     """Execute the complete Docker workflow logs process."""
-    # Check if workflow is running (timestamp file exists)
-    timestamp_file = self.timestamp_file_path
-    if not os.path.exists(timestamp_file):
-      Logger.instance(LOG_ID).info(f"Workflow '{self.workflow_name}' is not running. No timestamp file found: {timestamp_file}")
-      return
-    
-    from ...templates.constants import CORE_SERVICES
-    
+    timestamp_file = self.__find_and_verify_timestamp_file()
+     
     print_service_header = options.get('print_service_header')
     
     # Filter services based on options
@@ -420,4 +424,63 @@ class DockerWorkflowRunCommand(WorkflowRunCommand):
       result = subprocess.run(command, shell=True, **options)
       if result.returncode != 0:
         Logger.instance(LOG_ID).error(command)
-        sys.exit(1)
+        sys.exit(1)
+
+  def __find_and_verify_timestamp_file(self):
+    # Check if workflow is running (timestamp file exists)
+
+    timestamp_file = self.timestamp_file_path
+    if not os.path.exists(timestamp_file):
+      Logger.instance(LOG_ID).error(f"Workflow '{self.workflow_name}' is not running.")
+
+      if self.workflow_name != self.workflow_namespace.namespace:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow up {self.workflow_name} --namespace {self.workflow_namespace.namespace}` to start it first.")
+      else:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow up {self.workflow_name}` to start it first.")
+      sys.exit(2)
+
+    return timestamp_file
+
+  def __handle_up_active(self, folder: str, timestamp_file_path: str):
+    file_name = os.path.basename(timestamp_file_path)
+
+    # In the case of a namespace, the workflow name is the name of the file without the timestamp extension
+    workflow_name = self.workflow_name
+    if folder != self.workflow_name:
+      workflow_name = file_name.split(self.timestamp_file_extension)[0]
+
+    Logger.instance(LOG_ID).error(f"Workflow '{workflow_name}' is running, please stop it first.")
+
+    if folder != workflow_name:
+      Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {workflow_name} --namespace {folder}` to stop it first.")
+    else:
+      Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {workflow_name}` to stop it first.")
+
+    sys.exit(1)
+
+  def __iterate_active_workflows(self, **kwargs):
+    handle_active: FunctionType = kwargs.get('handle_active')
+    tmp_dir_path = self.app.data_dir.tmp_dir_path
+
+    # For each folder in self.app.data_dir.tmp_dir_path
+    for folder in os.listdir(tmp_dir_path):
+      folder_path = os.path.join(tmp_dir_path, folder)
+
+      # If the folder is not a directory, skip
+      if not os.path.isdir(folder_path):
+        continue
+
+      # For each file in folder_path that ends with .timestamp
+      for file in os.listdir(folder_path):
+        if not file.endswith(self.timestamp_file_extension):
+          continue
+
+        # If the folder contains a .timestamp file, then another workflow is running
+        timestamp_file_path = os.path.join(folder_path, file)
+
+        # Allow re-running the same workflow
+        if timestamp_file_path == self.timestamp_file_path:
+          continue
+
+        if handle_active:
+          handle_active(folder, timestamp_file_path)

stoobly_agent/app/cli/scaffold/local/workflow/run_command.py

@@ -4,6 +4,7 @@ import signal
 import subprocess
 import sys
 
+from types import FunctionType
 from typing import Optional, List
 
 from stoobly_agent.app.cli.scaffold.constants import PLUGIN_CYPRESS, PLUGIN_PLAYWRIGHT
@@ -34,26 +35,34 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
       self._log_file_path = os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.log")
     return self._log_file_path
 
+  @property
+  def pid_file_extension(self):
+    return '.pid'
+
   @property
   def pid_file_path(self):
     """Get the path to the PID file for this workflow."""
     if not self._pid_file_path:
-      self._pid_file_path = os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.pid")
+      self._pid_file_path = os.path.join(self.workflow_namespace.path, self.pid_file_name(self.workflow_name))
     return self._pid_file_path
 
+  def pid_file_name(self, workflow_name: str):
+    return f"{workflow_name}{self.pid_file_extension}"
+
   def _write_pid(self, pid: int):
     """Write the process PID to the PID file."""
     os.makedirs(os.path.dirname(self.pid_file_path), exist_ok=True)
     with open(self.pid_file_path, 'w') as f:
       f.write(str(pid))
 
-  def _read_pid(self) -> Optional[int]:
+  def _read_pid(self, file_path = None) -> Optional[int]:
     """Read the process PID from the PID file."""
-    if not os.path.exists(self.pid_file_path):
+    file_path = file_path or self.pid_file_path
+    if not os.path.exists(file_path):
       return None
     
     try:
-      with open(self.pid_file_path, 'r') as f:
+      with open(file_path, 'r') as f:
         return int(f.read().strip())
     except (ValueError, IOError):
       return None
@@ -130,9 +139,11 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
     """Start the workflow using local stoobly-agent run."""
     detached = options.get('detached', False)
 
-    commands = self.workflow_service_commands(**options)
+    self.__iterate_active_workflows(handle_active=self.__handle_up_active, handle_stale=self.__handle_up_stale)
 
     # iterate through each service in the workflow
+    commands = self.workflow_service_commands(**options)
+
     public_directory_paths = []
     response_fixtures_paths = []
     for command in commands:
@@ -145,18 +156,7 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
         if os.path.exists(command.response_fixtures_path):
           response_fixtures_paths.append('--response-fixtures-path')
           response_fixtures_paths.append(f"{command.response_fixtures_path}:{url}")
-    
-    # Check if PID file already exists
-    if os.path.exists(self.pid_file_path):
-      pid = self._read_pid()
-      if pid and self._is_process_running(pid):
-        Logger.instance(LOG_ID).error(f"Workflow {self.workflow_name} is already running with PID: {pid}")
-        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {self.workflow_name}` to stop it first")
-        sys.exit(1)
-      else:
-        # PID file exists but process is not running, clean it up
-        os.remove(self.pid_file_path)
-
+   
     for command in commands:
       command.service_up(**options)
 
@@ -166,17 +166,9 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
 
   def down(self, **options: WorkflowDownOptions):
     """Stop the workflow by killing the local process."""
-    
-    pid = self._read_pid()
+
+    pid = self.__find_and_verify_workflow_pid()
     if not pid:
-      Logger.instance(LOG_ID).warning(f"No PID file found for {self.workflow_name}")
-      return
-    
-    if not self._is_process_running(pid):
-      Logger.instance(LOG_ID).info(f"Process {pid} for {self.workflow_name} is not running")
-      # Clean up PID file
-      if os.path.exists(self.pid_file_path):
-        os.remove(self.pid_file_path)
       return
     
     # Kill the process
@@ -222,10 +214,8 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
     """Show logs for the local workflow process."""
     follow = options.get('follow', False)
     
-    pid = self._read_pid()
-    if not pid:
-      Logger.instance(LOG_ID).warning(f"No PID file found for {self.workflow_name}")
-      return
+    # Find and verify the workflow PID
+    self.__find_and_verify_workflow_pid()
     
     # Build log command
     log_file = f"{self.log_file_path}"
@@ -243,17 +233,6 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
       except subprocess.CalledProcessError as e:
         Logger.instance(LOG_ID).error(f"Failed to show logs for {self.workflow_name}: {e}")
 
-  def status(self):
-    """Check the status of the local workflow process."""
-    pid = self._read_pid()
-    if not pid:
-      return "not running"
-    
-    if self._is_process_running(pid):
-      return f"running (PID: {pid})"
-    else:
-      return "not running (stale PID file)"
-
   def workflow_service_commands(self, **options: WorkflowUpOptions):
     commands = list(map(lambda service_name: LocalWorkflowRunCommand(self.app, service_name=service_name, **options), self.services))
     commands.sort(key=lambda command: command.service_config.priority)
@@ -273,6 +252,79 @@ class LocalWorkflowRunCommand(WorkflowRunCommand):
     else:
       print(f"cat {log_file}", file=output_file)
 
+  def __find_and_verify_workflow_pid(self):
+    pid = self._read_pid()
+    if not pid:
+      Logger.instance(LOG_ID).error(f"Workflow {self.workflow_name} is not running.")
+
+      # If the workflow name does not match the workflow namespace, then recommend with --namespace option
+      if self.workflow_name != self.workflow_namespace.namespace:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow up {self.workflow_name} --namespace {self.workflow_namespace.namespace}` to start it first.")
+      else:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow up {self.workflow_name}` to start it first.")
+
+      sys.exit(1)
+    
+    if not self._is_process_running(pid):
+      Logger.instance(LOG_ID).info(f"Process {pid} for {self.workflow_name} is not running")
+      # Clean up PID file
+      if os.path.exists(self.pid_file_path):
+        os.remove(self.pid_file_path)
+      return
+
+    return pid
+
+  def __handle_up_active(self, folder: str, pid: str, pid_file_path: str):
+    # Allow re-running the same workflow, bring workflow down first
+    if pid_file_path == self.pid_file_path and os.path.exists(pid_file_path):
+      self.down()
+    else:
+      file_name = os.path.basename(pid_file_path)
+      workflow_name = self.workflow_name
+      if folder != self.workflow_name:
+        workflow_name = file_name.split(self.pid_file_extension)[0]
+
+      Logger.instance(LOG_ID).error(f"Workflow {workflow_name} is already running with PID {pid}")
+
+      if folder != workflow_name:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {workflow_name} --namespace {folder}` to stop it first.")
+      else:
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {workflow_name}` to stop it first.")
+
+      sys.exit(1)
+
+  def __handle_up_stale(self, folder: str, pid: str, pid_file_path: str):
+    # PID file exists but process is not running, clean it up
+    os.remove(pid_file_path)
+
+  def __iterate_active_workflows(self, **kwargs):
+    handle_active: FunctionType = kwargs.get('handle_active')
+    handle_stale: FunctionType = kwargs.get('handle_stale')
+    tmp_dir_path = self.app.data_dir.tmp_dir_path
+
+    # For each folder in self.app.data_dir.tmp_dir_path
+    for folder in os.listdir(tmp_dir_path):
+      folder_path = os.path.join(tmp_dir_path, folder)
+
+      # If the folder is not a directory, skip
+      if not os.path.isdir(folder_path):
+        continue
+
+      # For each file in folder_path that ends with .pid
+      for file in os.listdir(folder_path):
+        if not file.endswith(self.pid_file_extension):
+          continue
+          
+        # If the folder contains a .pid file, then another workflow is running
+        pid_file_path = os.path.join(folder_path, file)
+        pid = self._read_pid(pid_file_path)
+        if pid and self._is_process_running(pid):
+          if handle_active:
+            handle_active(folder, pid, pid_file_path)
+        else:
+          if handle_stale:
+            handle_stale(folder, pid, pid_file_path)
+
   def __up_command(self, public_directory_paths: List[str], response_fixtures_paths: List[str], **options: WorkflowUpOptions):
     # Build the stoobly-agent run command
     command = ['stoobly-agent', 'run']

stoobly_agent/app/cli/scaffold/service_dependency.py

@@ -37,7 +37,7 @@ class DockerImage:
             (?::(?P<tag>[^@]+))?             # optional :tag
             (?:@(?P<digest>.+))?             # optional @digest
         """
-        match = re.match(pattern, ref, re.VERBOSE)
+        match = re.fullmatch(pattern, ref, re.VERBOSE)
         if not match:
             raise ValueError(f"Invalid Docker image reference: {ref}")
         

stoobly_agent/app/cli/scaffold/service_workflow_validate_command.py

@@ -201,7 +201,12 @@ class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
     # Test workflow won't expose services that are detached and have a hostname to the host such as assets.
     # Need to test connection from inside the Docker network
     if self.service_config.hostname and self.workflow_name == WORKFLOW_TEST_TYPE:
-      self.validate_internal_hostname(url)
+      try:
+        self.validate_internal_hostname(url)
+      except ScaffoldValidateException:
+        time.sleep(1)
+        # Retry once
+        self.validate_internal_hostname(url)
 
     self.validate_init_containers(self.service_docker_compose.init_container_name, self.service_docker_compose.configure_container_name)
 

stoobly_agent/app/cli/scaffold/templates/app/.docker-compose.base.yml

@@ -4,6 +4,6 @@ services:
       service: stoobly_base
     volumes:
       - ${CONTEXT_DIR}/.stoobly:/home/stoobly/.stoobly
-      - ${APP_DIR}/.stoobly/docker:/home/stoobly/.stoobly/docker
+      - ${APP_DIR}/.stoobly/services:/home/stoobly/.stoobly/services
   stoobly_base:
     image: stoobly.${USER_ID}

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -170,7 +170,7 @@ class MitmproxyRequestFacade(Request):
         pattern = rewrite_rule.pattern
 
         try:
-            url_matches = re.match(pattern, self.url)
+            url_matches = re.fullmatch(pattern, self.url)
         except re.error as e:
             Logger.instance().error(f"RegExp error '{e}' for {pattern}")
             return False

stoobly_agent/app/proxy/mock/eval_fixtures_service.py

@@ -58,12 +58,9 @@ def eval_fixtures(request: MitmproxyRequest, **options: MockOptions) -> Union[Re
             continue
         
         # Try to find the file in this directory
-        _fixture_path = os.path.join(dir_path_config['path'], request_path.lstrip('/'))
+        fixture_path = os.path.join(dir_path_config['path'], request_path.lstrip('/'))
         if request.headers.get('accept'):
-          fixture_path = __guess_file_path(_fixture_path, request.headers['accept'])
-        
-        if not fixture_path:
-          fixture_path = _fixture_path
+          fixture_path = __guess_file_path(fixture_path, request.headers['accept'])
         
         if os.path.isfile(fixture_path):
           break
@@ -74,15 +71,31 @@ def eval_fixtures(request: MitmproxyRequest, **options: MockOptions) -> Union[Re
         return
     else:
       fixture_path = fixture.get('path')
-      if not fixture_path or not os.path.isfile(fixture_path):
+      if not fixture_path:
         return
 
+      if os.path.isdir(fixture_path):
+        request_path = request.path
+        match = re.match(fixture.get('path_pattern', request_path), request_path)
+
+        if not match or match.end() == len(request_path):
+          sub_path = 'index'
+        else:
+          sub_path = request_path[match.end():]
+
+        fixture_path = os.path.join(fixture_path, sub_path.lstrip('/'))
+        if request.headers.get('accept'):
+          fixture_path = __guess_file_path(fixture_path, request.headers['accept'])
+        
+      if not os.path.isfile(fixture_path):
+        return
+        
       _headers = fixture.get('headers')
       headers = CaseInsensitiveDict(_headers if isinstance(_headers, dict) else {}) 
 
       if fixture.get('status_code'):
         status_code = fixture.get('status_code')
-    
+
   with open(fixture_path, 'rb') as fp:
     response = Response()
 
@@ -158,13 +171,13 @@ def __guess_content_type(file_path):
     return
   return mimetypes.types_map.get(file_extension)
 
-def __guess_file_path(file_path, content_type):
+def __guess_file_path(file_path: str, content_type):
   file_extension = os.path.splitext(file_path)[1]
   if file_extension:
     return file_path
 
   if not content_type:
-    return
+    return file_path
 
   content_types = __parse_accept_header(content_type)
 
@@ -178,6 +191,8 @@ def __guess_file_path(file_path, content_type):
     if os.path.isfile(_file_path):
       return _file_path
 
+  return file_path
+
 def __find_fixture_for_request(request: MitmproxyRequest, fixtures: dict, method: str):
   """Find a fixture for the given request in the provided fixtures."""
   if not fixtures:
@@ -193,7 +208,7 @@ def __find_fixture_in_routes(fixtures: dict, method: str, request_path: str):
     return None
 
   for path_pattern in routes:
-    if not re.match(path_pattern, request_path):
+    if not re.fullmatch(path_pattern, request_path):
       continue
       
     fixture = routes[path_pattern]
@@ -203,6 +218,7 @@ def __find_fixture_in_routes(fixtures: dict, method: str, request_path: str):
     path = fixture.get('path')
 
     if path:
+      fixture['path_pattern'] = path_pattern
       return fixture
   
   return None
@@ -211,6 +227,9 @@ def __choose_highest_priority_content_type(accept_header: str) -> Optional[str]:
     if not accept_header:
         return None
 
+    if accept_header == '*/*':
+      return 'text/plain'
+
     types = []
     for part in accept_header.split(","):
         media_range = part.strip()
@@ -234,9 +253,13 @@ def __choose_highest_priority_content_type(accept_header: str) -> Optional[str]:
     return types[0][0] if types else None
 
 def __origin_matches(pattern: str, request_origin: str) -> bool:
-    return bool(re.match(pattern, request_origin))
+    return bool(re.fullmatch(pattern, request_origin))
 
 def __parse_accept_header(accept_header):
+    # In the case accept_header is */*, default to html and json file types
+    if accept_header == '*/*':
+      return ['text/html', 'application/json']
+
     types = []
     for item in accept_header.split(","):
         parts = item.split(";")

stoobly_agent/app/proxy/mock/eval_request_service.py

@@ -202,7 +202,7 @@ def __filter_by_match_rules(request: MitmproxyRequest, match_rules: List[MatchRu
 
 def __matches(url: str, pattern: str):
     try:
-        return re.match(pattern, url)
+        return re.fullmatch(pattern, url)
     except re.error as e:
         Logger.instance().error(f"RegExp error '{e}' for {pattern}")
         return False

stoobly_agent/app/proxy/utils/allowed_request_service.py

@@ -80,7 +80,7 @@ def __include(request: MitmproxyRequest, patterns: List[str]) -> bool:
 
     for pattern in patterns:
         try:
-            if re.match(pattern, request.url):
+            if re.fullmatch(pattern, request.url):
                 return True
         except re.error as e:
             Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")
@@ -94,7 +94,7 @@ def __exclude(request: MitmproxyRequest, patterns: List[str]) -> bool:
 
     for pattern in patterns:
         try:
-            if re.match(pattern, request.url):
+            if re.fullmatch(pattern, request.url):
                 return True
         except re.error as e:
             Logger.instance(LOG_ID).error(f"RegExp error '{e}' for {pattern}")

stoobly_agent/lib/cache.py

@@ -32,7 +32,7 @@ class Cache:
         else:
             delete_list = []
             for key in self.data.keys():
-                if re.match(pattern, key):
+                if re.fullmatch(pattern, key):
                     delete_list.append(key)
             
             for key in delete_list:

stoobly_agent/test/app/models/schemas/.stoobly/db/VERSION

@@ -1 +1 @@
-1.10.1
+1.10.2