stoobly-agent 0.34.13__py3-none-any.whl → 1.0.1__py3-none-any.whl

stoobly_agent/app/cli/scaffold/templates/workflow/test/lifecycle_hooks.py

@@ -0,0 +1,12 @@
+# This file defines lifecyle hooks for when Stoobly intercepts a request
+from stoobly_agent.app.proxy.mock.context import MockContext
+
+def handle_before_request(context: MockContext):
+    intercept_settings = context.intercept_settings
+    flow = context.flow
+    request = flow.request
+
+    # For example, uncomment the following
+    #print(f"Agent running in {intercept_settings.mode} mode with {intercept_settings.policy} policy")
+    #print(dir(request))
+        

stoobly_agent/app/cli/scaffold/workflow.py

@@ -0,0 +1,49 @@
+import os
+
+from typing import List
+
+from .app import App
+
+class Workflow():
+
+  def __init__(self, workflow_name: str, app: App):
+    self.__app = app
+    self.__workflow_name = workflow_name
+
+  @property
+  def app(self):
+    return self.__app
+
+  @property
+  def workflow_name(self):
+    return self.__workflow_name
+
+  @property
+  def service(self):
+    return self._service
+
+  @service.setter
+  def service(self, v):
+    self._service = v
+
+  @property
+  def services(self):
+    return list(map(lambda path: os.path.basename(path), self.service_paths))
+
+  @property
+  def service_paths(self):
+    services_dir = os.path.join(self.app.scaffold_dir_path, self.app.namespace)
+
+    services = []
+    for filename in os.listdir(services_dir):
+      path = os.path.join(services_dir, filename)
+      if not os.path.isdir(path):
+        continue
+      
+      services.append(path)
+
+    return services
+
+  def service_paths_from_services(self, services: List[str]):
+    app_namespace_path = self.app.namespace_path
+    return list(map(lambda service: os.path.join(app_namespace_path, service), services))

stoobly_agent/app/cli/scaffold/workflow_command.py

@@ -0,0 +1,137 @@
+import os
+import pdb
+import yaml
+
+from stoobly_agent.lib.logger import Logger
+
+from .app import App
+from .config import Config
+from .constants import COMPOSE_TEMPLATE, CONFIG_FILE, ENV_FILE, FIXTURES_FOLDER_NAME
+from .docker.constants import DOCKER_COMPOSE_CUSTOM
+from .service_command import ServiceCommand
+
+LOG_ID = 'WorkflowCommand'
+
+class WorkflowCommand(ServiceCommand):
+
+  def __init__(self, app: App, **kwargs):
+    super().__init__(app, **kwargs)
+
+    self.__workflow_name = kwargs['workflow_name']
+
+  @property
+  def compose_path(self):
+    return os.path.join(
+      self.scaffold_dir_path,
+      self.compose_relative_path
+    )
+
+  @property
+  def compose_relative_path(self):
+    return os.path.join(
+      self.workflow_relative_path, 
+      COMPOSE_TEMPLATE.format(workflow=self.workflow_name)
+    )
+
+  @property
+  def containers(self):
+    _containers = []
+    if not os.path.exists(self.compose_path):
+      return []
+
+    with open(self.compose_path, 'r') as fp:
+      config = yaml.safe_load(fp)
+      services = config.get('services')
+      if not isinstance(services, dict):
+        return []
+
+      for service in services:
+        _containers.append(f"{self.workflow_name}-{service}-1")
+        
+    return _containers
+
+  @property
+  def custom_compose(self):
+    if os.path.exists(self.custom_compose_path):
+      with open(self.custom_compose_path, 'r') as fp:
+        compose = yaml.safe_load(fp)
+        if compose and not isinstance(compose, dict):
+          Logger.instance(LOG_ID).warn(f"Could not parse {self.custom_compose_path} as YAML")
+          return {}
+        return compose
+
+  @property
+  def custom_compose_relative_path(self):
+    return os.path.join(
+      self.workflow_relative_path,
+      DOCKER_COMPOSE_CUSTOM
+    )
+
+  @property
+  def custom_compose_path(self):
+    return os.path.join(
+      self.scaffold_dir_path,
+      self.custom_compose_relative_path
+    )
+
+  @property
+  def custom_services(self):
+    custom_compose = self.custom_compose
+
+    if not custom_compose:
+      return {}
+    
+    services = custom_compose.get('services')
+    if not isinstance(services, dict):
+      return {}
+
+    return services
+
+  @property
+  def fixtures_dir_path(self):
+    return os.path.join(self.workflow_path, FIXTURES_FOLDER_NAME)
+
+  @property
+  def workflow_config(self):
+    return Config(self.workflow_config_path).read()
+
+  @property
+  def workflow_config_path(self):
+    return os.path.join(self.workflow_path, CONFIG_FILE)
+
+  @property
+  def workflow_env_path(self):
+    return os.path.join(self.workflow_path, ENV_FILE)
+
+  @property
+  def workflow_exists(self):
+    return os.path.exists(self.workflow_path)
+
+  @property
+  def workflow_name(self):
+    return self.__workflow_name
+
+  @property
+  def workflow_path(self):
+    return os.path.join(
+      self.scaffold_dir_path,
+      self.workflow_relative_path
+    )
+
+  @property
+  def workflow_relative_path(self):
+    return os.path.join(
+      self.service_relative_path,
+      self.workflow_name
+    )
+
+  @property
+  def workflow_templates_root_dir(self):
+    return os.path.join(self.templates_root_dir, 'workflow')
+  
+  def env(self, _c: dict):
+    _config = self.app_config.read()
+    _config.update(self.service_config)
+    _config.update(self.workflow_config)
+    _config.update(_c)
+    return _config

stoobly_agent/app/cli/scaffold/workflow_copy_command.py

@@ -0,0 +1,45 @@
+import os
+import pdb
+import shutil
+
+from .app import App
+from .constants import COMPOSE_TEMPLATE, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
+from .service_workflow import ServiceWorkflow
+from .workflow_command import WorkflowCommand
+
+CORE_WORKFLOWS = [WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]
+
+class WorkflowCopyCommand(WorkflowCommand):
+
+  def __init__(self, app: App, **kwargs):
+    super().__init__(app, **kwargs)
+
+    self.__force = not not kwargs.get('force')
+
+  @property
+  def force(self):
+    return self.__force
+
+  def copy(self, destination_workflow_name: str):
+    destination_workflow = ServiceWorkflow(self.service_name, destination_workflow_name, self.app)
+
+    # Create workflow folder
+    dest = os.path.join(destination_workflow.path)
+    if os.path.exists(dest) and self.force:
+        shutil.rmtree(dest)
+
+    if not os.path.exists(dest):
+      os.makedirs(dest) 
+
+    self.app.copy_folders_and_hidden_files(self.workflow_path, dest)
+
+    compose_file_src = os.path.join(dest, COMPOSE_TEMPLATE.format(workflow=self.workflow_name))
+    compose_file_dest = os.path.join(dest, COMPOSE_TEMPLATE.format(workflow=destination_workflow_name))
+    os.rename(compose_file_src, compose_file_dest)
+
+    # Replace workflow name
+    with open(compose_file_dest, 'r+') as fp:
+      contents = fp.read()
+      fp.seek(0)
+      fp.write(contents.replace(self.workflow_name, destination_workflow_name))
+      fp.truncate()

stoobly_agent/app/cli/scaffold/workflow_create_command.py

@@ -0,0 +1,94 @@
+import os
+import pdb
+import shutil
+
+from typing import List, TypedDict, Union
+
+from .app import App
+from .constants import WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE, WORKFLOW_TEMPLATE
+from .docker.service.builder import ServiceBuilder
+from .docker.workflow.mock_decorator import MockDecorator
+from .docker.workflow.reverse_proxy_decorator import ReverseProxyDecorator
+from .docker.workflow.builder import WorkflowBuilder
+from .templates.factory import custom_files, maintained_files
+from .workflow_command import WorkflowCommand
+
+CORE_WORKFLOWS = [WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]
+
+class BuildOptions(TypedDict):
+  builder_class: type 
+  headless: bool
+  service_builder: ServiceBuilder
+  template: WORKFLOW_TEMPLATE
+  workflow_decorators: List[Union[MockDecorator, ReverseProxyDecorator]]
+
+class WorkflowCreateCommand(WorkflowCommand):
+
+  def __init__(self, app: App, **kwargs):
+    super().__init__(app, **kwargs)
+
+    self.__env_vars: List[str] = kwargs.get('env') or []
+    self.__force = not not kwargs.get('force')
+
+  @property
+  def workflow_templates_path(self):
+    return self.build_workflow_templates_path(self.workflow_name)
+
+  @property
+  def env_vars(self):
+    return self.__env_vars
+
+  @property
+  def force(self):
+    return self.__force
+
+  def build(self, **kwargs: BuildOptions):
+    # Create workflow folder
+    dest = os.path.join(self.workflow_path)
+    if os.path.exists(dest) and self.force:
+        shutil.rmtree(dest)
+
+    if not os.path.exists(dest):
+      os.makedirs(dest) 
+
+    # Create workflow maintained compose file
+    workflow_builder = self.__write_docker_compose_file(**kwargs)
+    self.__copy_templates(workflow_builder, kwargs.get('template'))
+
+  def build_workflow_templates_path(self, workflow_name: str):
+    return os.path.join(self.workflow_templates_root_dir, workflow_name)
+
+  def __copy_templates(self, workflow_builder: WorkflowBuilder, template: WORKFLOW_TEMPLATE = None):
+    if not template:
+      templates_path = self.workflow_templates_path
+    else:
+      templates_path = self.build_workflow_templates_path(template)
+
+    if not os.path.exists(templates_path):
+      return
+
+    # Maintained files are files that will always be overwritten
+    maintained_workflow_files = maintained_files(self.workflow_name, workflow_builder)
+    self.copy_files(templates_path, maintained_workflow_files, self.workflow_path)
+
+    # Custom files are files that may be modified by the user
+    custom_workflow_files = custom_files(self.workflow_name, workflow_builder)
+    self.copy_files_no_replace(templates_path, custom_workflow_files, self.workflow_path)
+
+  def __write_docker_compose_file(self, **kwargs: BuildOptions):
+    builder_class = kwargs.get('builder_class') or WorkflowBuilder
+    service_builder = kwargs.get('service_builder') or ServiceBuilder(self.service_config)
+    workflow_decorators: List[Union[MockDecorator, ReverseProxyDecorator]] = kwargs.get('workflow_decorators')
+
+    workflow_builder = builder_class(self.workflow_path, service_builder)
+    workflow_builder.with_env(list(self.env_vars))
+    workflow_builder.build_all()
+
+    if isinstance(workflow_decorators, list):
+      for workflow_decorator in workflow_decorators:
+        workflow_decorator(workflow_builder).decorate()
+
+    workflow_builder.write()
+    workflow_builder.initialize_custom_file()
+
+    return workflow_builder

stoobly_agent/app/cli/scaffold/workflow_log_command.py

@@ -0,0 +1,21 @@
+import os
+import pdb
+import yaml
+
+from .app import App
+from .workflow_command import WorkflowCommand
+
+class WorkflowLogCommand(WorkflowCommand):
+  def __init__(self, app: App, **kwargs):
+    super().__init__(app, **kwargs)
+
+  def all(self):
+    commands = []
+    containers = self.containers
+
+    for container in containers:
+      command = ['docker', 'logs', container]
+
+      commands.append(' '.join(command))
+
+    return commands

stoobly_agent/app/cli/scaffold/workflow_run_command.py

@@ -0,0 +1,134 @@
+import os
+import pdb
+
+from stoobly_agent.config.data_dir import DataDir
+from stoobly_agent.lib.logger import Logger
+
+from .app import App
+from .constants import APP_NETWORK_ENV, CERTS_DIR_ENV, CONTEXT_DIR_ENV, SERVICE_NAME_ENV, USER_ID_ENV, WORKFLOW_NAME_ENV
+from .env import Env
+from .workflow_command import WorkflowCommand
+
+LOG_ID = 'WorkflowRunCommand'
+
+class WorkflowRunCommand(WorkflowCommand):
+  def __init__(self, app: App, **kwargs):
+    super().__init__(app, **kwargs)
+
+    self.__current_working_dir = os.getcwd()
+    self.__certs_dir_path = app.certs_dir_path
+    self.__context_dir_path = app.context_dir_path
+    self.__extra_compose_path = kwargs.get('extra_compose_path')
+    self.__network = kwargs.get('network') or app.network
+
+  @property
+  def certs_dir_path(self):
+    if not self.__certs_dir_path:
+      data_dir = DataDir.instance()
+      dir_path = os.path.join(data_dir.tmp_dir_path, 'certs')
+      if not os.path.exists(dir_path):
+          os.mkdir(dir_path)
+
+    return self.__certs_dir_path
+
+  @property
+  def context_dir_path(self):
+    if not self.__context_dir_path:
+      data_dir = DataDir.instance()
+      return os.path.dirname(data_dir.path) 
+
+    return self.__context_dir_path
+
+  @property
+  def current_working_dir(self):
+    return self.__current_working_dir
+
+  @current_working_dir.setter
+  def current_working_dir(self, v):
+    self.__current_working_dir = v
+
+  @property
+  def extra_compose_path(self):
+    return self.__extra_compose_path
+
+  @property
+  def network(self):
+    return self.__network
+
+  def create_network(self):
+    return f"docker network create {self.network} 2> /dev/null"
+
+  def up(self):
+    if not os.path.exists(self.compose_path):
+      return ''
+
+    command = ['COMPOSE_IGNORE_ORPHANS=true', 'docker', 'compose']
+
+    # Add docker compose file
+    command.append(f"-f {os.path.relpath(self.compose_path, self.__current_working_dir)}")
+
+    # Add custom docker compose file
+    custom_services = self.custom_services
+  
+    if custom_services:
+      uses_profile = False
+      for service_name in custom_services:
+        service = custom_services[service_name]
+        profiles = service.get('profiles')
+        if isinstance(profiles, list):
+          if self.workflow_name in profiles:
+            uses_profile = True
+            break
+      if not uses_profile:
+        # TODO: looking into why warning does not print in docker
+        Logger.instance(LOG_ID).error(f"Missing {self.workflow_name} profile in custom compose file")
+
+      command.append(f"-f {os.path.relpath(self.custom_compose_path, self.__current_working_dir)}")
+
+    if self.extra_compose_path:
+      command.append(f"-f {os.path.relpath(self.extra_compose_path, self.__current_working_dir)}")
+
+    command.append(f"--profile {self.workflow_name}") 
+    command.append('up')
+    command.append('-d')
+    command.append('--build')
+
+    self.write_env()
+
+    return ' '.join(command)
+
+  def down(self):
+    if not os.path.exists(self.compose_path):
+      return ''
+  
+    command = ['docker', 'compose']
+
+    # Add docker compose file
+    command.append(f"-f {os.path.relpath(self.compose_path, os.getcwd())}")
+
+    # Add custom docker compose file
+    if self.custom_services:
+      command.append(f"-f {os.path.relpath(self.custom_compose_path, self.__current_working_dir)}")
+
+    if self.extra_compose_path:
+      command.append(f"-f {os.path.relpath(self.extra_compose_path, self.__current_working_dir)}")
+
+    command.append(f"--profile {self.workflow_name}") 
+    command.append('down')
+
+    return ' '.join(command)
+
+  def write_env(self):
+    _config = {}
+    _config[CERTS_DIR_ENV] = self.certs_dir_path
+    _config[CONTEXT_DIR_ENV] = self.context_dir_path
+    _config[SERVICE_NAME_ENV] = self.service_name
+    _config[USER_ID_ENV] = os.getuid()
+    _config[WORKFLOW_NAME_ENV] = self.workflow_name
+
+    if self.network:
+      _config[APP_NETWORK_ENV] = self.network
+
+    env_vars = self.config(_config)
+    env_path = self.workflow_env_path
+    Env(env_path).write(env_vars)