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

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '0.34.13'
+VERSION = '1.0.0'

stoobly_agent/app/cli/__init__.py

@@ -8,6 +8,7 @@ from .main_group import MainGroup
 from .project_cli import project
 from .report_cli import report
 from .request_cli import request
+from .scaffold_cli import scaffold
 from .scenario_cli import scenario
 from .snapshot_cli import snapshot
 from .trace_cli import trace

stoobly_agent/app/cli/helpers/openapi_endpoint_adapter.py

@@ -4,7 +4,8 @@ import re
 import yaml
 
 from functools import reduce
-from openapi_core import Spec
+from jsonschema_path import SchemaPath
+from openapi_core import OpenAPI
 from pprint import pprint
 from typing import Dict, List, Union
 from urllib.parse import urlparse
@@ -35,11 +36,12 @@ class OpenApiEndpointAdapter():
       if missing_oauth2_scopes:
         self.__add_oauth2_default_scopes(file_data)
 
-      spec = Spec.from_dict(file_data)
+      openApi = OpenAPI.from_dict(file_data)
+      spec = openApi.spec
 
     return self.adapt(spec)
 
-  def adapt(self, spec: Spec) -> List[EndpointShowResponse]:
+  def adapt(self, spec: SchemaPath) -> List[EndpointShowResponse]:
     endpoints = []
     endpoint_counter = 0
     components = spec.get("components", {})
@@ -364,7 +366,7 @@ class OpenApiEndpointAdapter():
   
 
   # Returns the schema object located at the given reference path
-  def __dereference(self, components: Spec, reference: str):
+  def __dereference(self, components: SchemaPath, reference: str):
     # '#/components/schemas/NewPet'
     if not reference.startswith('#'):
       print('external references are not supported yet')
@@ -475,7 +477,7 @@ class OpenApiEndpointAdapter():
     num = url.count('{')
     return num
 
-  def __evaluate_servers(self, servers: Spec) -> List[dict]:
+  def __evaluate_servers(self, servers: SchemaPath) -> List[dict]:
     result = []
 
     if not servers:
@@ -524,7 +526,7 @@ class OpenApiEndpointAdapter():
     
     return result
 
-  def __parse_responses(self, endpoint: EndpointShowResponse, responses: Spec, components: Spec):
+  def __parse_responses(self, endpoint: EndpointShowResponse, responses: SchemaPath, components: SchemaPath):
     for response_code, response_definition in responses.items():
       # Only support status code 200 for now
       if response_code != '200':
@@ -566,4 +568,4 @@ class OpenApiEndpointAdapter():
           
         if not endpoint.get('response_header_names'):
           endpoint['response_header_names'] = []
-        endpoint['response_header_names'].append(response_header_name)	  
+        endpoint['response_header_names'].append(response_header_name)	  

stoobly_agent/app/cli/helpers/shell.py

@@ -0,0 +1,28 @@
+import subprocess
+import sys
+
+from dotenv import load_dotenv
+
+def exec_stream(command):
+  load_dotenv()
+
+  # Start the process
+  process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+  
+  # Stream output line by line
+  while True:
+      stdout = process.stdout.readline()
+      stderr = process.stderr.readline()
+
+      if stdout == '' and stderr == '' and process.poll() is not None:
+          break
+
+      if stdout:
+          print(stdout, end='')
+
+      if stderr:
+          print(stderr, end='', file=sys.stderr)
+  
+  # Get the remaining output (if any)
+  rc = process.poll()
+  return rc

stoobly_agent/app/cli/main_group.py

@@ -26,7 +26,7 @@ class MainGroup(click.Group):
     command_groups: List[CommandGroup] = [
       {
         'name': 'Commands',
-        'commands': ['dev-tools', 'exec', 'feature', 'init', 'mock', 'record'],
+        'commands': ['dev-tools', 'exec', 'feature', 'init', 'mock', 'record', 'scaffold'],
       },
       {
         'name': 'Proxy Commands',

stoobly_agent/app/cli/scaffold/app.py

@@ -0,0 +1,106 @@
+import os
+import shutil
+
+from stoobly_agent.config.data_dir import DataDir, DATA_DIR_NAME
+
+class App():
+
+  def __init__(self, path: str, namespace: str, **kwargs):
+    path = path or os.getcwd()
+    data_dir: DataDir = DataDir.instance(path) 
+
+    self.__scaffold_dir_path = data_dir.path
+    self.__certs_dir_path = os.path.join(data_dir.tmp_dir_path, 'certs')
+    self.__context_dir_path = data_dir.context_dir_path
+    self.__dir_path = path
+    self.__name = os.path.basename(self.__dir_path)
+    self.__network = os.path.basename(self.__dir_path)
+    self.__namespace = namespace
+    self.__skip_validate_path = not not kwargs.get('skip_validate_path')
+
+  @property
+  def certs_dir_path(self):
+    return self.__certs_dir_path
+
+  @certs_dir_path.setter
+  def certs_dir_path(self, v: str):
+    self.__validate_path(v)
+    self.__certs_dir_path = v
+
+  @property
+  def context_dir_path(self):
+    return self.__context_dir_path
+
+  @context_dir_path.setter
+  def context_dir_path(self, v: str):
+    self.__validate_path(v)
+    self.__context_dir_path = v 
+
+  @property
+  def data_dir_path(self):
+    return os.path.join(self.context_dir_path, DATA_DIR_NAME)
+
+  @property
+  def exists(self):
+    return os.path.exists(self.dir_path)
+
+  @property
+  def name(self):
+    return self.__name
+
+  @name.setter
+  def name(self, v: str):
+    self.__name = v
+
+  @property
+  def network(self):
+    return self.__network
+
+  @network.setter
+  def network(self, v: str):
+    self.__network = v
+
+  @property
+  def namespace(self):
+    return self.__namespace
+
+  @property
+  def namespace_path(self):
+    return os.path.join(self.data_dir_path, self.namespace)
+
+  @property
+  def dir_path(self):
+    return self.__dir_path
+
+  @property
+  def scaffold_dir_path(self):
+    return self.__scaffold_dir_path
+
+  @property
+  def scaffold_namespace_path(self):
+    return os.path.join(self.scaffold_dir_path, self.namespace)
+
+  def copy_folders_and_hidden_files(self, src, dst):
+      os.makedirs(dst, exist_ok=True)
+
+      # Walk through the source directory
+      for root, dirs, files in os.walk(src):
+          # Copy hidden files only
+          for file_name in files:
+              src_file_path = os.path.join(root, file_name)
+              dst_file_path = os.path.join(dst, os.path.relpath(root, src), file_name)
+
+              if not file_name.startswith('.'):
+                  if os.path.exists(dst_file_path):
+                      continue
+
+              os.makedirs(os.path.dirname(dst_file_path), exist_ok=True)  # Create directories in destination
+              shutil.copy2(src_file_path, dst_file_path)
+
+  def __validate_path(self, v: str):
+    if not isinstance(v, str):
+      raise TypeError('Expected a str')
+
+    if not self.__skip_validate_path:
+      if not os.path.exists(v):
+        raise ValueError(f"{v} does not exist")

stoobly_agent/app/cli/scaffold/app_command.py

@@ -0,0 +1,82 @@
+import os
+import pathlib
+import shutil
+
+from .app import App
+from .app_config import AppConfig
+from .command import Command
+
+class AppCommand(Command):
+
+  def __init__(self, app: App):
+    super().__init__(app)
+
+    self.__config = AppConfig(self.scaffold_namespace_path)
+    self.__config.network = app.network
+
+  @property
+  def app_dir_path(self):
+    return self.app.dir_path
+
+  @property
+  def app_dir_exists(self):
+    return os.path.exists(self.app_dir_path)
+
+  @property
+  def app_config(self):
+    return self.__config
+
+  @property
+  def app_config_path(self):
+    return self.__config.path
+
+  @property
+  def app_namespace_path(self):
+    return self.app.namespace_path
+
+  @property
+  def app_templates_root_dir(self):
+    return os.path.join(self.templates_root_dir, 'app')
+
+  @property
+  def scaffold_dir_path(self):
+    return self.app.scaffold_dir_path
+
+  @property
+  def scaffold_namespace_path(self):
+    return self.app.scaffold_namespace_path
+
+  @property
+  def templates_root_dir(self):
+    return os.path.join(pathlib.Path(__file__).parent.resolve(), 'templates')
+
+  def config(self, _c: dict):
+    _config = self.app_config.read()
+    _config.update(_c)
+    return _config
+
+  def copy_files_no_replace(self, source_dir: str, src_files: list, dest_dir: str):
+    return self.copy_files(source_dir, src_files, dest_dir, False)
+
+  def copy_files(self, source_dir: str, src_files: list, dest_dir: str, replace_ok=True):
+    # Ensure the destination directory exists
+    if not os.path.exists(dest_dir):
+        os.makedirs(dest_dir)
+    
+    for file in src_files:
+      src_file_path = os.path.join(source_dir, file)
+      if not os.path.isfile(src_file_path):
+        continue
+      
+      if not os.path.exists(src_file_path):
+        continue
+
+      dest_subdir = os.path.join(dest_dir, os.path.dirname(file))
+
+      if os.path.exists(os.path.join(dest_dir, file)) and not replace_ok:
+        continue
+
+      if not os.path.exists(dest_subdir):
+        os.makedirs(dest_subdir, exist_ok=True)
+
+      shutil.copy(src_file_path, dest_subdir)

stoobly_agent/app/cli/scaffold/app_config.py

@@ -0,0 +1,32 @@
+from .config import Config
+from .constants import APP_NETWORK_ENV
+
+class AppConfig(Config):
+
+  def __init__(self, dir: str):
+    super().__init__(dir)
+
+    self.__network = None
+
+    self.load()
+
+  @property
+  def network(self):
+    return self.__network
+
+  @network.setter
+  def network(self, v):
+    self.__network = v
+
+  def load(self, config = None):
+    config = config or self.read()
+
+    self.__network = config.get(APP_NETWORK_ENV)
+    
+  def write(self):
+    config = {}
+
+    if self.network:
+      config[APP_NETWORK_ENV] = self.network
+
+    super().write(config)

stoobly_agent/app/cli/scaffold/app_create_command.py

@@ -0,0 +1,24 @@
+import os
+import pdb
+
+from .app import App
+from .app_command import AppCommand
+
+class AppCreateCommand(AppCommand):
+
+    def __init__(self, app: App, **kwargs):
+        super().__init__(app)
+
+    @property
+    def app_name(self):
+        return self.app.name
+
+    def build(self):
+        dest = self.scaffold_namespace_path
+
+        self.app.copy_folders_and_hidden_files(self.app_templates_root_dir, dest)
+
+        with open(os.path.join(dest, '.gitignore'), 'w') as fp:
+            fp.write("\n".join(['**/.env', '**/.config.yml']))
+
+        self.app_config.write()

stoobly_agent/app/cli/scaffold/command.py

@@ -0,0 +1,15 @@
+from .app import App
+
+class Command():
+
+  def __init__(self, app: App):
+    self.__app = app
+    self.__namespace = app.namespace
+
+  @property
+  def app(self):
+    return self.__app
+
+  @property
+  def namespace(self):
+    return self.__namespace

stoobly_agent/app/cli/scaffold/config.py

@@ -0,0 +1,35 @@
+import os
+import yaml
+
+from .constants import CONFIG_FILE
+
+class Config():
+
+  def __init__(self, dir: str, file_name = None):
+    self.__dir = dir
+    self.__path = os.path.join(dir, file_name or CONFIG_FILE)
+
+  @property
+  def dir(self):
+    return self.__dir
+
+  @property
+  def path(self):
+    return self.__path
+
+  def read(self, source: str = None):
+    if not source:
+      source = self.path
+
+    config = {}
+
+    if os.path.exists(source):
+      with open(source, 'r') as fp:
+        config = yaml.safe_load(fp)
+        
+    return config
+
+  def write(self, config: dict):
+    config_path = os.path.join(self.path)
+    with open(config_path, 'w') as fp:
+      yaml.dump(config, fp)

stoobly_agent/app/cli/scaffold/constants.py

@@ -0,0 +1,35 @@
+from typing import Literal
+
+APP_NETWORK_ENV = 'APP_NETWORK'
+CERTS_DIR_ENV = 'CERTS_DIR'
+COMPOSE_TEMPLATE = '.docker-compose.{workflow}.yml'
+CONFIG_FILE = '.config.yml'
+CONTEXT_DIR_ENV = 'CONTEXT_DIR'
+DOCKER_NAMESPACE = 'docker'
+ENV_FILE = '.env'
+FIXTURES_FOLDER_NAME = 'fixtures'
+SERVICE_DETACHED = '${SERVICE_DETACHED}'
+SERVICE_DETACHED_ENV = 'SERVICE_DETACHED'
+SERVICE_DOCKER_COMPOSE_PATH = '${SERVICE_DOCKER_COMPOSE_PATH}'
+SERVICE_DOCKER_COMPOSE_PATH_ENV = 'SERVICE_DOCKER_COMPOSE_PATH'
+SERVICE_HOSTNAME = '${SERVICE_HOSTNAME}'
+SERVICE_HOSTNAME_ENV = 'SERVICE_HOSTNAME'
+SERVICE_DNS = '${SERVICE_DNS}'
+SERVICE_DNS_ENV = 'SERVICE_DNS'
+SERVICE_NAME_ENV = 'SERVICE_NAME'
+SERVICE_PROXY_MODE = '${SERVICE_PROXY_MODE}'
+SERVICE_PROXY_MODE_ENV = 'SERVICE_PROXY_MODE'
+SERVICE_SCHEME = '${SERVICE_SCHEME}'
+SERVICE_SCHEME_ENV = 'SERVICE_SCHEME'
+SERVICE_PORT = '${SERVICE_PORT}'
+SERVICE_PORT_ENV = 'SERVICE_PORT'
+SERVICE_PRIORITY_ENV = 'SERVICE_PRIORITY'
+STOOBLY_HOME_DIR = '/home/stoobly'
+USER_ID_ENV = 'USER_ID'
+WORKFLOW_CUSTOM_FILTER = 'custom'
+WORKFLOW_MOCK_TYPE = 'mock'
+WORKFLOW_NAME_ENV = 'WORKFLOW_NAME'
+WORKFLOW_RECORD_TYPE = 'record'
+WORKFLOW_TEST_TYPE = 'test'
+
+WORKFLOW_TEMPLATE = Literal[WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]

stoobly_agent/app/cli/scaffold/docker/app_builder.py

@@ -0,0 +1,26 @@
+import os
+
+from .builder import Builder
+from .constants import DOCKER_COMPOSE_BASE, DOCKERFILE_CONTEXT, DOCKERFILE_PROXY
+from ..app_config import AppConfig
+
+class AppBuilder(Builder):
+
+  def __init__(self, config: AppConfig):
+    super().__init__(config.dir, DOCKER_COMPOSE_BASE)
+
+  @property
+  def context_base(self):
+    return 'context_base'
+
+  @property
+  def context_docker_file_path(self):
+    return os.path.join(self.dir_path, DOCKERFILE_CONTEXT)
+
+  @property
+  def proxy_base(self):
+    return 'proxy_base'
+
+  @property
+  def proxy_docker_file_path(self):
+    return os.path.join(self.dir_path, DOCKERFILE_PROXY)

stoobly_agent/app/cli/scaffold/docker/builder.py

@@ -0,0 +1,117 @@
+import os
+import pathlib
+import pdb
+import yaml
+
+from .constants import APP_NETWORK, DOCKER_COMPOSE_CUSTOM, GATEWAY_NETWORK
+
+class Builder():
+
+  def __init__(self, dir_path: str, compose_file_name: str):
+    self.__compose_file_name = compose_file_name
+    self.__dir_path = dir_path
+    self.__networks = {}
+    self.__services = {}
+    self.__templates_dir = os.path.join(pathlib.Path(__file__).parent.parent.resolve(), 'templates')
+    self.__volumes = {}
+
+  @property
+  def compose_file_name(self):
+    return self.__compose_file_name
+
+  @property
+  def compose_file_path(self):
+    return os.path.join(self.dir_path, self.compose_file_name)
+
+  @property
+  def custom_compose_file_path(self):
+    return os.path.join(
+      self.dir_path,
+      DOCKER_COMPOSE_CUSTOM
+    )
+
+  @property
+  def dir_path(self):
+    return self.__dir_path
+
+  @property
+  def public_network(self):
+    return self.__networks.get(GATEWAY_NETWORK)
+
+  @property
+  def public_network_name(self):
+    return GATEWAY_NETWORK
+
+  @property
+  def networks(self):
+    return self.__networks
+
+  @property
+  def services(self):
+    return self.__services
+
+  @property
+  def templates_dir(self):
+    return self.__templates_dir
+
+  @property
+  def volumes(self):
+    return self.__volumes
+
+  def build_extends(self, service_name: str, source_dir: str):
+    return {
+      'file': os.path.relpath(self.compose_file_path, source_dir),
+      'service': service_name
+    }
+
+  # If the file already exists, load the specified resources
+  def load(self):
+    if not os.path.exists(self.compose_file_path):
+      return
+
+    with open(self.compose_file_path, 'r') as fp:
+      contents = yaml.safe_load(fp) or {}
+
+      networks = contents.get('networks')
+      if isinstance(networks, dict):
+        self.__networks = networks
+
+      services = contents.get('services')
+      if isinstance(services, dict):
+        self.__services = services
+
+      volumes = contents.get('volumes')
+      if isinstance(volumes, dict):
+        self.__volumes = volumes
+
+  def with_network(self, network):
+    self.__networks[network] = {
+      'name': network
+    }
+    return self
+
+  def with_public_network(self, network = APP_NETWORK):
+    self.__networks[GATEWAY_NETWORK] = {
+      'external': True,
+      'name': network,
+    }
+    return self
+
+  def with_service(self, service_name: str, service: dict):
+    self.__services[service_name] = service
+    return self
+
+  def with_volume(self, volume_name: str, volume: dict = {}):
+    self.__volumes[volume_name] = volume
+    return self
+
+  def write(self, compose: dict, path = None):
+    path = path or self.compose_file_path
+    parent_dir = os.path.dirname(path)
+
+    if not os.path.exists(parent_dir):
+      os.makedirs(parent_dir)
+
+    with open(path, 'w') as fp:
+      yaml.dump(compose, fp, allow_unicode=True)
+      fp.close()

stoobly_agent/app/cli/scaffold/docker/constants.py

@@ -0,0 +1,7 @@
+APP_NETWORK = '${APP_NETWORK}'
+DOCKER_COMPOSE_BASE = '.docker-compose.base.yml'
+DOCKER_COMPOSE_CUSTOM = 'docker-compose.yml'
+DOCKERFILE_CONTEXT = '.Dockerfile.context'
+DOCKERFILE_PROXY = '.Dockerfile.proxy'
+DOCKERFILE_SERVICE = 'Dockerfile.source'
+GATEWAY_NETWORK = 'gateway'

stoobly_agent/app/cli/scaffold/docker/service/build_decorator.py

@@ -0,0 +1,37 @@
+import pdb
+
+from typing import TypedDict
+
+from ...constants import DOCKER_NAMESPACE
+from ..constants import DOCKERFILE_SERVICE
+from .builder import ServiceBuilder
+from .types import BuildDecoratorOptions
+
+class BuildDecorator():
+
+  def __init__(self, service_builder: ServiceBuilder):
+    self.__service_builder = service_builder
+
+  def decorate(self, **kwargs: BuildDecoratorOptions):
+    service_builder = self.__service_builder
+    build = {
+      'context': '../..', # Assumes app root is 2 levels up
+      'dockerfile': f"./{DOCKER_NAMESPACE}/{service_builder.service_name}/{DOCKERFILE_SERVICE}"
+    }
+
+    if 'build_args' in kwargs:
+      args = {}
+      for arg in kwargs['build_args']:
+        args[arg] = '${' + arg + '}'
+      build['args'] = args
+
+    services = self.__service_builder.services
+    app_name = self.__service_builder.app_base
+    app_service = services.get(app_name) or {}
+
+    services[app_name] = { 
+      **app_service,
+      **{ 
+          'build': build,
+        } 
+    }