stoobly-agent 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '1.0.6'
+VERSION = '1.0.8'

stoobly_agent/app/cli/scaffold/constants.py

@@ -1,5 +1,8 @@
 from typing import Literal
 
+from stoobly_agent.config.data_dir import DATA_DIR_NAME
+
+
 APP_NETWORK_ENV = 'APP_NETWORK'
 CA_CERTS_DIR_ENV = 'CA_CERTS_DIR'
 CERTS_DIR_ENV = 'CERTS_DIR'
@@ -26,11 +29,16 @@ SERVICE_PORT = '${SERVICE_PORT}'
 SERVICE_PORT_ENV = 'SERVICE_PORT'
 SERVICE_PRIORITY_ENV = 'SERVICE_PRIORITY'
 STOOBLY_HOME_DIR = '/home/stoobly'
+STOOBLY_DATA_DIR = f"{STOOBLY_HOME_DIR}/{DATA_DIR_NAME}"
 USER_ID_ENV = 'USER_ID'
+VIRTUAL_HOST_ENV = 'VIRTUAL_HOST'
+VIRTUAL_PORT_ENV = 'VIRTUAL_PORT'
+VIRTUAL_PROTO_ENV = 'VIRTUAL_PROTO'
 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]
+WORKFLOW_TEMPLATE = Literal[WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]
+

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

@@ -5,3 +5,9 @@ DOCKERFILE_CONTEXT = '.Dockerfile.context'
 DOCKERFILE_PROXY = '.Dockerfile.proxy'
 DOCKERFILE_SERVICE = 'Dockerfile.source'
 GATEWAY_NETWORK = 'gateway'
+
+# TODO: add scaffold container name templates here
+
+# Example:
+# COMPOSE_TEMPLATE = 'docker-compose.{workflow}.yml'
+

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

@@ -182,7 +182,6 @@ class WorkflowBuilder(Builder):
 
     depends_on = {}
     environment = { **self.env_dict() }
-    extra_hosts = []
     networks = [self.service_builder.service_name]
     volumes = []
 
@@ -190,7 +189,6 @@ class WorkflowBuilder(Builder):
       'build': self.proxy_build, 
       'depends_on': depends_on,
       'environment': environment,
-      'extra_hosts': extra_hosts,
       'extends': self.service_builder.build_extends_proxy_base(self.dir_path),
       'networks': networks,
       'profiles': self.profiles,

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

@@ -37,4 +37,4 @@ class MockDecorator():
     services[proxy_name] = { 
       **proxy_service,
       **{ 'command': command, 'hostname': f"{SERVICE_HOSTNAME}" },
-    }
+    }

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

@@ -62,4 +62,3 @@ class ReverseProxyDecorator():
 
     services[proxy_name] = service 
 
-

stoobly_agent/app/cli/scaffold/managed_services_docker_compose.py

@@ -0,0 +1,9 @@
+
+class ManagedServicesDockerCompose():
+  def __init__(self, target_workflow_name):
+    self.init_container_name = f"{target_workflow_name}-build.init-1"
+    self.configure_container_name = f"{target_workflow_name}-build.configure-1"
+    self.gateway_container_name = f"{target_workflow_name}-gateway.service-1"
+    self.mock_ui_container_name = f"{target_workflow_name}-stoobly_ui.service-1"
+    self.entrypoint_init_container_name = f"{target_workflow_name}-entrypoint.init-1"
+    self.entrypoint_configure_container_name = f"{target_workflow_name}-entrypoint.configure-1"

stoobly_agent/app/cli/scaffold/service_command.py

@@ -5,6 +5,7 @@ from .app import App
 from .app_command import AppCommand
 from .service_config import ServiceConfig
 
+
 class ServiceCommand(AppCommand):
 
   def __init__(self, app: App, **kwargs):
@@ -47,4 +48,5 @@ class ServiceCommand(AppCommand):
     _config = self.app_config.read()
     _config.update(self.service_config.read())
     _config.update(_c)
-    return _config
+    return _config
+

stoobly_agent/app/cli/scaffold/service_config.py

@@ -210,4 +210,5 @@ class ServiceConfig(Config):
       
     # Split the DNS servers string into a list
     dns_servers = match[0].strip().split("\n")
-    return list(map(lambda dns_server: dns_server.strip(), dns_servers))
+    return list(map(lambda dns_server: dns_server.strip(), dns_servers))
+

stoobly_agent/app/cli/scaffold/service_docker_compose.py

@@ -0,0 +1,15 @@
+from stoobly_agent.config.data_dir import DataDir
+
+
+class ServiceDockerCompose():
+  def __init__(self, app_dir_path, target_workflow_name, service_name, hostname):
+    self.service_name = service_name
+    self.hostname = hostname
+    self.container_name = f"{target_workflow_name}-{service_name}-1"
+    self.proxy_container_name = f"{target_workflow_name}-{service_name}.proxy-1"
+    self.init_container_name = f"{target_workflow_name}-{service_name}.init-1"
+    self.configure_container_name = f"{target_workflow_name}-{service_name}.configure-1"
+
+    data_dir_path = DataDir.instance(app_dir_path).path
+    self.docker_compose_path = f"{data_dir_path}/docker/{service_name}/{target_workflow_name}/docker-compose.yml"
+    self.init_script_path = f"{data_dir_path}/docker/{service_name}/{target_workflow_name}/bin/init"

stoobly_agent/app/cli/scaffold/service_workflow_validate_command.py

@@ -0,0 +1,234 @@
+import os
+import pdb
+import ssl
+from collections import Counter
+from pathlib import Path
+
+import requests
+import yaml
+from docker.models.containers import Container
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+from stoobly_agent.app.cli.scaffold.constants import (
+  FIXTURES_FOLDER_NAME,
+  STOOBLY_DATA_DIR,
+  STOOBLY_HOME_DIR,
+  VIRTUAL_HOST_ENV,
+  VIRTUAL_PORT_ENV,
+  VIRTUAL_PROTO_ENV,
+  WORKFLOW_RECORD_TYPE,
+  WORKFLOW_TEST_TYPE,
+)
+from stoobly_agent.app.cli.scaffold.service_command import ServiceCommand
+from stoobly_agent.app.cli.scaffold.service_docker_compose import ServiceDockerCompose
+from stoobly_agent.app.cli.scaffold.validate_command import ValidateCommand
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
+from stoobly_agent.config.data_dir import DATA_DIR_NAME
+
+from .app import App
+
+
+class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
+  def __init__(self, app: App, **kwargs):
+    ServiceCommand.__init__(self, app, **kwargs)
+    ValidateCommand.__init__(self)
+
+    self.workflow_name = kwargs['workflow_name']
+    self.hostname = self.service_config.hostname
+    self.service_docker_compose = ServiceDockerCompose(app_dir_path=app.dir_path, target_workflow_name=self.workflow_name, service_name=self.service_name, hostname=self.hostname)
+
+  @property
+  def fixtures_dir_path(self):
+    return os.path.join(self.workflow_path, FIXTURES_FOLDER_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
+    )
+
+  def is_local(self):
+    with open (self.service_docker_compose.docker_compose_path,'rb') as f:
+      docker_compose_file_content = yaml.safe_load(f)
+      if docker_compose_file_content and docker_compose_file_content.get('services'):
+        return True
+
+      # We can potentially check the port too someday
+
+    return False
+
+  def is_external(self):
+    return not self.is_local()
+
+  def hostname_reachable(self, url: str) -> None:
+    # Retry HTTP request. Source: https://stackoverflow.com/questions/15431044/can-i-set-max-retries-for-requests-request
+    session = requests.Session()
+    retries = Retry(total=5,
+                    backoff_factor=0.1,
+                    status_forcelist=[ 500, 502, 503, 504 ])
+    session.mount('http://', HTTPAdapter(max_retries=retries))
+    session.mount('https://', HTTPAdapter(max_retries=retries))
+
+    # Use default OpenSSL path to CA certs on the system
+    default_ssl_verify_paths = ssl.get_default_verify_paths()
+    default_capath = default_ssl_verify_paths.capath
+
+    response = session.get(url=url, verify=default_capath)
+    if not response.ok:
+      raise ScaffoldValidateException(f"Host is not reachable: {url}")
+ 
+  def validate_hostname(self, url: str) -> None:
+    print(f"Validating hostname: {url}")
+    self.hostname_reachable(url)
+
+    # TODO: check logs of proxy. lifecycle hook for custom logging? Does mitmproxy support json logging?
+
+  def validate_internal_hostname(self, url: str) -> None:
+    print(f"Validating hostname inside Docker network, url: {url}")
+    
+    timeout_seconds = 1
+    output = self.docker_client.containers.run(
+      image='curlimages/curl:8.11.0',
+      command=f"curl --max-time {timeout_seconds} {url} --verbose",
+      network=self.app_config.network,
+      stderr=True,
+      remove=True,
+    )
+
+    # Note: 499 error could also mean success because it shows the proxy
+    # connection is working, but we haven't recorded anything yet
+    logs = output.decode('ascii')
+    if ('200 OK' not in logs) and ('499' not in logs):
+      raise ScaffoldValidateException(f"Error reaching {url} from inside Docker network")
+
+  # Check fixtures folder mounted into container
+  def validate_fixtures_folder(self, container: Container):
+    
+    if self.workflow_name == WORKFLOW_RECORD_TYPE:
+      print(f"Skipping validating fixtures folder in workflow: {self.workflow_name}, container: {container.name}")
+      return
+
+    print(f"Validating fixtures folder in container: {container.name}")
+
+    data_dir_mounted = False
+    volume_mounts = container.attrs['Mounts']
+
+    for volume_mount in volume_mounts:
+      if volume_mount['Destination'] == STOOBLY_DATA_DIR:
+        data_dir_mounted = True
+        break
+    if not data_dir_mounted:
+      raise ScaffoldValidateException(f"Data directory is not mounted for: {container.name}")
+
+    # Only the running proxy containers will be checkable
+    if container.status == 'exited':
+      print(f"Skipping validating fixtures folder contents because container is exited: {container.name}")
+      return
+
+    # Check contents of fixtures folder to confirm it's shared
+    fixtures_folder_path = f"{STOOBLY_HOME_DIR}/{self.workflow_name}/{FIXTURES_FOLDER_NAME}"
+    exec_result = container.exec_run(f"ls -A {fixtures_folder_path}")
+    output = exec_result.output
+
+    fixtures_folder_contents_container = output.decode('ascii').split('\n')
+    if fixtures_folder_contents_container[-1] == '':
+      fixtures_folder_contents_container.pop()
+    fixtures_folder_contents_scaffold = os.listdir(self.fixtures_dir_path)
+
+    if Counter(fixtures_folder_contents_container) != Counter(fixtures_folder_contents_scaffold):
+      raise ScaffoldValidateException(f"Fixtures was not mounted properly, expected {self.fixtures_dir_path} to exist in container path {fixtures_folder_path}")
+
+  # Note: might not need this if the hostname is reachable and working
+  def proxy_environment_variables_exist(self, container: Container) -> None:
+    environment_variables = container.attrs['Config']['Env']
+    virtual_host_exists = False
+    virtual_port_exists = False
+    virtual_proto_exists = False
+
+    for environment_variable in environment_variables:
+      environment_variable_name, environment_variable_value = environment_variable.split('=')
+      if environment_variable_name == VIRTUAL_HOST_ENV:
+        virtual_host_exists = True
+      elif environment_variable_name == VIRTUAL_PORT_ENV:
+        virtual_port_exists = True
+      elif environment_variable_name == VIRTUAL_PROTO_ENV:
+        virtual_proto_exists = True
+
+    if not virtual_host_exists:
+      raise ScaffoldValidateException(f"VIRTUAL_HOST environment variable is missing from container: {container.name}")
+    if not virtual_port_exists:
+      raise ScaffoldValidateException(f"VIRTUAL_POST environment variable is missing from container: {container.name}")
+    if not virtual_proto_exists:
+      raise ScaffoldValidateException(f"VIRTUAL_PROTO environment variable is missing from container: {container.name}")
+
+  
+  def validate_proxy_container(self, service_proxy_container: Container):
+    print(f"Validating proxy container: {service_proxy_container.name}")
+    if not service_proxy_container.attrs:
+      raise ScaffoldValidateException(f"Container attributes are missing for: {container.name}")
+
+    if not self.service_config.detached:
+      self.validate_fixtures_folder(service_proxy_container)
+
+    self.proxy_environment_variables_exist(service_proxy_container)
+
+  def validate_service_container(self):
+    pass
+  
+  def validate(self) -> bool:
+    print(f"Validating service: {self.service_name}")
+
+    url = f"{self.service_config.scheme}://{self.hostname}"
+
+    if self.service_config.hostname and self.workflow_name not in [WORKFLOW_TEST_TYPE]:
+      self.validate_hostname(url)
+    
+    # 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 and self.service_config.detached:
+      self.validate_internal_hostname(url)
+
+    self.validate_init_containers(self.service_docker_compose.init_container_name, self.service_docker_compose.configure_container_name)
+
+    # Service init containers have a mounted dist folder unlike the core init container
+    init_container = self.docker_client.containers.get(self.service_docker_compose.init_container_name)
+    self.validate_fixtures_folder(init_container)
+
+    if self.service_config.hostname:
+      service_proxy_container = self.docker_client.containers.get(self.service_docker_compose.proxy_container_name)
+      self.validate_proxy_container(service_proxy_container)
+
+    if self.is_local():
+      print(f"Validating local user defined service: {self.service_name}")
+      # Validate docker-compose path exists
+      docker_compose_path = f"{self.app_dir_path}/{DATA_DIR_NAME}/docker/{self.service_docker_compose.service_name}/{self.workflow_name}/docker-compose.yml"
+      destination_path = Path(docker_compose_path)
+      if not destination_path.is_file():
+        raise ScaffoldValidateException(f"Docker compose path is not a file: {destination_path}")
+
+      # Validate docker-compose.yml file has the service defined
+      with open(destination_path) as f:
+        if self.service_name not in f.read():
+          raise ScaffoldValidateException(f"Local service is not defined in Docker Compose file: {destination_path}")
+
+      service_container = self.docker_client.containers.get(self.service_docker_compose.container_name)
+      if service_container.status == 'exited':
+        return False
+
+    if self.service_config.detached:
+      service_container = self.docker_client.containers.get(self.service_docker_compose.container_name)
+      self.validate_detached(service_container)
+
+    print(f"Done validating service: {self.service_name}, success!")
+    print()
+
+    return True
+

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

@@ -1,9 +1,9 @@
 import os
 
 CORE_BUILD_SERVICE_NAME = 'build'
-CORE_MOCK_UI_SERVICE_NAME = 'stoobly-ui'
-CORE_GATEWAY_SERVICE_NAME = 'gateway'
 CORE_ENTRYPOINT_SERVICE_NAME = 'entrypoint'
+CORE_GATEWAY_SERVICE_NAME = 'gateway'
+CORE_MOCK_UI_SERVICE_NAME = 'stoobly-ui'
 CORE_SERVICES = [
   CORE_BUILD_SERVICE_NAME, CORE_ENTRYPOINT_SERVICE_NAME, CORE_MOCK_UI_SERVICE_NAME, CORE_GATEWAY_SERVICE_NAME 
 ]
@@ -60,4 +60,4 @@ TEST_WORKFLOW_CUSTOM_FILES = [
   CUSTOM_LIFECYCLE_HOOKS
 ]
 
-SERVICE_HOSTNAME_BUILD_ARG = 'SERVICE_HOSTNAME'
+SERVICE_HOSTNAME_BUILD_ARG = 'SERVICE_HOSTNAME'

stoobly_agent/app/cli/scaffold/validate_command.py

@@ -0,0 +1,59 @@
+import pdb
+from time import sleep
+
+import docker
+from docker import errors as docker_errors
+from docker.models.containers import Container
+
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
+from stoobly_agent.config.data_dir import DATA_DIR_NAME
+
+
+class ValidateCommand():
+  def __init__(self):
+    self.docker_client = docker.from_env()
+
+  # Some containers like init and configure can take longer than expected to finish so retry
+  def __get_container(self, container_name: str) -> Container:
+    tries = 30
+    for _ in range(tries):
+      try:
+        container = self.docker_client.containers.get(container_name)
+        return container
+      except docker_errors.NotFound:
+        sleep(0.5)
+
+    raise ScaffoldValidateException(f"Container not found: {container_name}")
+
+  def validate_init_containers(self, init_container_name, configure_container_name) -> None:
+    print(f"Validating setup containers: {init_container_name}, {configure_container_name}")
+
+
+    init_container = self.__get_container(init_container_name)
+    logs = init_container.logs()
+    if logs:
+      raise ScaffoldValidateException(f"Error logs potentially detected in: {init_container_name}")
+    if init_container.status != 'exited' or init_container.attrs['State']['ExitCode'] != 0:
+      raise ScaffoldValidateException(f"init container has not exited like expected: {init_container_name}")
+
+    configure_container = self.__get_container(configure_container_name)
+
+    configure_container_ran = False
+    if configure_container.status == 'exited' and configure_container.attrs['State']['ExitCode'] == 0:
+      configure_container_ran = True
+    if not configure_container_ran:
+      raise ScaffoldValidateException(f"Configure container has not ran as expected: {configure_container_name}")
+  
+  def validate_detached(self, container: Container) -> None:
+    print(f"Validating detached for: {container.name}")
+    
+    if not container.attrs:
+      raise ScaffoldValidateException(f"Container is missing: {container.name}")
+
+    volume_mounts = container.attrs['Mounts']
+    for volume_mount in volume_mounts:
+      if DATA_DIR_NAME in volume_mount['Source']:
+        return
+
+    raise ScaffoldValidateException(f"Data directory is missing from container: {container.name}")
+

stoobly_agent/app/cli/scaffold/validate_exceptions.py

@@ -0,0 +1,5 @@
+
+
+class ScaffoldValidateException(Exception):
+  pass
+

stoobly_agent/app/cli/scaffold/workflow.py

@@ -1,9 +1,10 @@
 import os
-
+import pdb
 from typing import List
 
 from .app import App
 
+
 class Workflow():
 
   def __init__(self, workflow_name: str, app: App):
@@ -34,6 +35,26 @@ class Workflow():
   def service_paths(self):
     return self.app.service_paths
 
+  # TODO: merge into 1 services property
+
+  # Returns services that run in this specific workflow
+  @property
+  def services_ran(self) -> List[str]:
+    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
+
+      for sub_path in os.scandir(path):
+        if os.path.isdir(sub_path):
+          if sub_path.name == self.workflow_name:
+            services.append(filename)
+
+    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_run_command.py

@@ -137,4 +137,5 @@ class WorkflowRunCommand(WorkflowCommand):
 
     env_vars = self.config(_config)
     env_path = self.workflow_env_path
-    Env(env_path).write(env_vars)
+    Env(env_path).write(env_vars)
+

stoobly_agent/app/cli/scaffold/workflow_validate_command.py

@@ -0,0 +1,94 @@
+import pdb
+
+from docker import errors as docker_errors
+
+from stoobly_agent.app.cli.scaffold.constants import WORKFLOW_TEST_TYPE
+from stoobly_agent.app.cli.scaffold.managed_services_docker_compose import (
+  ManagedServicesDockerCompose,
+)
+from stoobly_agent.app.cli.scaffold.templates.constants import (
+  CORE_ENTRYPOINT_SERVICE_NAME,
+  CORE_GATEWAY_SERVICE_NAME,
+  CORE_MOCK_UI_SERVICE_NAME,
+  CORE_SERVICES,
+)
+from stoobly_agent.app.cli.scaffold.validate_command import ValidateCommand
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
+from stoobly_agent.app.cli.scaffold.workflow_command import WorkflowCommand
+
+from .app import App
+
+
+class WorkflowValidateCommand(WorkflowCommand, ValidateCommand):
+  def __init__(self, app: App, **kwargs):
+    WorkflowCommand.__init__(self, app, **kwargs)
+    ValidateCommand.__init__(self)
+    self.managed_services_docker_compose = ManagedServicesDockerCompose(target_workflow_name=self.workflow_name)
+
+  def validate_core_components(self):
+    print(f"Validating core component: {CORE_GATEWAY_SERVICE_NAME}")
+    gateway_container_name = self.managed_services_docker_compose.gateway_container_name
+    gateway_container = self.docker_client.containers.get(gateway_container_name)
+    if not gateway_container or (gateway_container.status != 'running'):
+      raise ScaffoldValidateException(f"Container '{gateway_container_name}' not found for service '{CORE_GATEWAY_SERVICE_NAME}'")
+
+    print(f"Validating core component: {CORE_MOCK_UI_SERVICE_NAME}")
+    mock_ui_container_name = self.managed_services_docker_compose.mock_ui_container_name
+    mock_ui_container = self.docker_client.containers.get(mock_ui_container_name)
+    if not mock_ui_container or (mock_ui_container.status != 'running'):
+      raise ScaffoldValidateException(f"Container '{mock_ui_container_name}' not found for service '{CORE_MOCK_UI_SERVICE_NAME}'")
+
+  def validate_no_core_components(self):
+    try:
+      core_gateway_container = self.docker_client.containers.get(self.managed_services_docker_compose.gateway_container_name)
+      if core_gateway_container:
+        raise ScaffoldValidateException(f"Gateway container is running when it shouldn't: {core_gateway_container.name}")
+    except docker_errors.NotFound:
+      pass
+    
+    try:
+      core_mock_ui_container_name = self.docker_client.containers.get(self.managed_services_docker_compose.mock_ui_container_name)
+      if core_mock_ui_container_name:
+        raise ScaffoldValidateException(f"Stoobly UI container is running when it shouldn't: {core_mock_ui_container_name.name}")
+    except docker_errors.NotFound:
+      pass
+    
+    print(f"Skipping validating core component: {CORE_GATEWAY_SERVICE_NAME}")
+    print(f"Skipping validating core component: {CORE_MOCK_UI_SERVICE_NAME}")
+
+  
+  def validate(self) -> bool:
+    print(f"Validating workflow: {self.workflow_name}")
+    print(f"Validating core components: {CORE_SERVICES}")
+
+    if self.workflow_name == WORKFLOW_TEST_TYPE:
+      # Don't validate the gateway and mock_ui core components in the "test" workflow 
+      self.validate_no_core_components()
+    else:
+      self.validate_core_components()
+
+    self.validate_init_containers(self.managed_services_docker_compose.init_container_name, self.managed_services_docker_compose.configure_container_name)
+
+    print(f"Validating core component: {CORE_ENTRYPOINT_SERVICE_NAME}")
+
+    try:
+      core_entrypoint_init_container_name = self.managed_services_docker_compose.entrypoint_init_container_name
+      entrypoint_init_container = self.docker_client.containers.get(core_entrypoint_init_container_name)
+    except docker_errors.NotFound:
+      raise ScaffoldValidateException(f"Container not found: {core_entrypoint_init_container_name}")
+
+    try:
+      core_entrypoint_configure_container_name = self.managed_services_docker_compose.entrypoint_configure_container_name
+      entrypoint_configure_container = self.docker_client.containers.get(core_entrypoint_configure_container_name)
+    except docker_errors.NotFound:
+      raise ScaffoldValidateException(f"Container not found: {core_entrypoint_configure_container_name}")
+
+    # NOTE: we should check the correct workflow mode is enabled one day
+    # That's not currently queryable
+
+    print(f"Done validating workflow: {self.workflow_name}, success!")
+    print()
+
+    return True
+
+

stoobly_agent/app/cli/scaffold_cli.py

@@ -9,6 +9,7 @@ from stoobly_agent.app.cli.helpers.certificate_authority import CertificateAutho
 from stoobly_agent.app.cli.helpers.shell import exec_stream
 from stoobly_agent.app.cli.scaffold.app import App
 from stoobly_agent.app.cli.scaffold.app_create_command import AppCreateCommand
+from stoobly_agent.app.cli.scaffold.constants import DOCKER_NAMESPACE, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
 from stoobly_agent.app.cli.scaffold.constants import (
   DOCKER_NAMESPACE, WORKFLOW_CUSTOM_FILTER, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
 )
@@ -17,12 +18,15 @@ from stoobly_agent.app.cli.scaffold.docker.workflow.decorators_factory import ge
 from stoobly_agent.app.cli.scaffold.service import Service
 from stoobly_agent.app.cli.scaffold.service_config import ServiceConfig
 from stoobly_agent.app.cli.scaffold.service_create_command import ServiceCreateCommand
+from stoobly_agent.app.cli.scaffold.service_workflow_validate_command import ServiceWorkflowValidateCommand
 from stoobly_agent.app.cli.scaffold.templates.constants import CORE_SERVICES
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
 from stoobly_agent.app.cli.scaffold.workflow import Workflow
 from stoobly_agent.app.cli.scaffold.workflow_create_command import WorkflowCreateCommand
 from stoobly_agent.app.cli.scaffold.workflow_copy_command import WorkflowCopyCommand
 from stoobly_agent.app.cli.scaffold.workflow_log_command import WorkflowLogCommand
 from stoobly_agent.app.cli.scaffold.workflow_run_command import WorkflowRunCommand
+from stoobly_agent.app.cli.scaffold.workflow_validate_command import WorkflowValidateCommand
 from stoobly_agent.config.constants import env_vars
 from stoobly_agent.config.data_dir import DataDir
 from stoobly_agent.lib.logger import bcolors, DEBUG, ERROR, INFO, Logger, WARNING
@@ -324,6 +328,9 @@ def logs(**kwargs):
 def run(**kwargs):
   cwd = os.getcwd()
 
+  # Create the certs_dir_path if it doesn't exist
+  DataDir.instance().certs_dir_path
+
   if not os.getenv(env_vars.LOG_LEVEL):
     os.environ[env_vars.LOG_LEVEL] = kwargs['log_level']
 
@@ -376,7 +383,37 @@ def run(**kwargs):
       exec_stream(exec_command)
     else:
       print(exec_command)
- 
+
+@workflow.command(
+  help="Validate a scaffold workflow"
+)
+@click.option('--app-dir-path', default=os.getcwd(), help='Path to validate the app scaffold.')
+@click.argument('workflow_name')
+def validate(**kwargs):
+  app = App(kwargs['app_dir_path'], DOCKER_NAMESPACE)
+  workflow = Workflow(kwargs['workflow_name'], app)
+  
+  config = { **kwargs }
+  config['service_name'] = 'build'
+
+  try:
+    command = WorkflowValidateCommand(app, **config)
+    command.validate()
+  except ScaffoldValidateException as sve:
+    print(f"\nFatal Scaffold Validation Exception: {sve}", file=sys.stderr)
+    sys.exit(1)
+
+  try:
+    for service in workflow.services_ran:
+      if service not in CORE_SERVICES:
+        config['service_name'] = service
+        command = ServiceWorkflowValidateCommand(app, **config)
+        command.validate()
+  except ScaffoldValidateException as sve:
+    print(f"\nFatal Scaffold Validation Exception: {sve}", file=sys.stderr)
+    sys.exit(1)
+
+
 scaffold.add_command(app)
 scaffold.add_command(service)
 scaffold.add_command(workflow)
@@ -431,4 +468,5 @@ def __workflow_build(app, **kwargs):
     headless=kwargs['headless'],
     template=kwargs['template'],
     workflow_decorators=workflow_decorators
-  )
+  )
+