Add generated kind config (#623)

add fixturenet-laconicd test

.gitea/workflows/fixturenet-laconicd-test.yml

@@ -0,0 +1,55 @@
+name: Fixturenet-Laconicd-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-laconicd-test'
+
+# Needed until we can incorporate docker startup into the executor container
+env:
+  DOCKER_HOST: unix:///var/run/dind.sock
+
+
+jobs:
+  test:
+    name: "Run an Laconicd fixturenet test"
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Update'
+        run: apt-get update
+      - name: 'Setup jq'
+        run: apt-get install jq -y
+      - name: 'Check jq'
+        run: |
+          which jq
+          jq --version
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      # At present the stock setup-python action fails on Linux/aarch64
+      # Conditional steps below workaroud this by using deadsnakes for that case only
+      - name: "Install Python for ARM on Linux"
+        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
+        uses: deadsnakes/action@v3.0.1
+        with:
+          python-version: '3.8'
+      - name: "Install Python cases other than ARM on Linux"
+        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: Start dockerd # Also needed until we can incorporate into the executor
+        run: |
+          dockerd -H $DOCKER_HOST --userland-proxy=false &
+          sleep 5
+      - name: "Run fixturenet-laconicd tests"
+        run: ./tests/fixturenet-laconicd/run-test.sh

.gitea/workflows/triggers/fixturenet-laconicd-test

@@ -0,0 +1,2 @@
+Change this file to trigger running the fixturenet-laconicd-test CI job
+

.github/workflows/fixturenet-laconicd.yml

@@ -0,0 +1,30 @@
+name: Fixturenet-Laconicd Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.github/workflows/triggers/fixturenet-laconicd-test'
+
+jobs:
+  test:
+    name: "Run fixturenet-laconicd test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Clone project repository"
+        uses: actions/checkout@v3
+      - name: "Install Python"
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.8'
+      - name: "Print Python version"
+        run: python3 --version
+      - name: "Install shiv"
+        run: pip install shiv
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Run fixturenet-laconicd tests"
+        run: ./tests/fixturenet-laconicd/run-test.sh

.github/workflows/triggers/fixturenet-laconicd-test

@@ -0,0 +1,3 @@
+Change this file to trigger running the fixturenet-laconicd-test CI job
+
+trigger

app/data/container-build/cerc-act-runner-task-executor/build.sh

@@ -2,4 +2,4 @@
 # Build a local version of the task executor for act-runner
 source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-docker build -t cerc/act-runner-task-executor:local -f ${CERC_REPO_BASE_DIR}/hosting/gitea/Dockerfile.task-executor ${build_command_args} ${SCRIPT_DIR}
+docker build -t cerc/act-runner-task-executor:local -f ${CERC_REPO_BASE_DIR}/hosting/act-runner/Dockerfile.task-executor ${build_command_args} ${SCRIPT_DIR}

app/data/stacks/act-runner/README.md

@@ -0,0 +1,13 @@
+# act-runner stack
+
+## Example
+
+```
+$ laconic-so --stack act-runner deploy init --output act-runner-1.yml --config CERC_GITEA_RUNNER_REGISTRATION_TOKEN=FOO
+$ laconic-so --stack act-runner deploy create --spec-file act-runner-1.yml --deployment-dir ~/opt/deployments/act-runner-1
+$ laconic-so deployment --dir ~/opt/deployments/act-runner-1 up
+
+$ laconic-so --stack act-runner deploy init --output act-runner-2.yml --config CERC_GITEA_RUNNER_REGISTRATION_TOKEN=BAR
+$ laconic-so --stack act-runner deploy create --spec-file act-runner-2.yml --deployment-dir ~/opt/deployments/act-runner-2
+$ laconic-so deployment --dir ~/opt/deployments/act-runner-2 up
+```

app/data/stacks/act-runner/stack.yml

@@ -0,0 +1,15 @@
+version: "1.1"
+name: act-runner
+description: "Local act-runner"
+repos:
+  - git.vdb.to/cerc-io/hosting
+  - gitea.com/gitea/act_runner
+containers:
+  - cerc/act-runner
+  - cerc/act-runner-task-executor
+pods:
+  - name: act-runner
+    repository: cerc-io/hosting
+    path: act-runner
+    pre_start_command: "pre_start.sh"
+    post_start_command: "post_start.sh"

app/data/stacks/package-registry/stack.yml

@@ -13,3 +13,8 @@ pods:
     path: gitea
     pre_start_command: "run-this-first.sh"
     post_start_command: "initialize-gitea.sh"
+  - name: act-runner
+    repository: cerc-io/hosting
+    path: act-runner
+    pre_start_command: "pre_start.sh"
+    post_start_command: "post_start.sh"

app/deploy/compose/deploy_docker.py

@@ -13,8 +13,9 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
+from pathlib import Path
 from python_on_whales import DockerClient, DockerException
-from app.deploy.deployer import Deployer, DeployerException
+from app.deploy.deployer import Deployer, DeployerException, DeployerConfigGenerator
 
 
 class DockerDeployer(Deployer):
@@ -48,9 +49,9 @@ class DockerDeployer(Deployer):
         except DockerException as e:
             raise DeployerException(e)
 
-    def execute(self, service, command, envs):
+    def execute(self, service, command, tty, envs):
         try:
-            return self.docker.compose.execute(service=service, command=command, envs=envs)
+            return self.docker.compose.execute(service=service, command=command, tty=tty, envs=envs)
         except DockerException as e:
             raise DeployerException(e)
 
@@ -65,3 +66,14 @@ class DockerDeployer(Deployer):
             return self.docker.run(image=image, command=command, user=user, volumes=volumes, entrypoint=entrypoint)
         except DockerException as e:
             raise DeployerException(e)
+
+
+class DockerDeployerConfigGenerator(DeployerConfigGenerator):
+    config_file_name: str = "kind-config.yml"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    # Nothing needed at present for the docker deployer
+    def generate(self, deployment_dir: Path):
+        pass

app/deploy/deploy.py

@@ -307,7 +307,7 @@ def _make_cluster_context(ctx, stack, include, exclude, cluster, env_file):
                 compose_file_name = os.path.join(compose_dir, f"docker-compose-{pod_path}.yml")
             else:
                 if deployment:
-                    compose_file_name = os.path.join(compose_dir, "docker-compose.yml")
+                    compose_file_name = os.path.join(compose_dir, f"docker-compose-{pod_name}.yml")
                     pod_pre_start_command = pod["pre_start_command"]
                     pod_post_start_command = pod["post_start_command"]
                     script_dir = compose_dir.parent.joinpath("pods", pod_name, "scripts")
@@ -317,7 +317,7 @@ def _make_cluster_context(ctx, stack, include, exclude, cluster, env_file):
                         post_start_commands.append(os.path.join(script_dir, pod_post_start_command))
                 else:
                     pod_root_dir = os.path.join(dev_root_path, pod_repository.split("/")[-1], pod["path"])
-                    compose_file_name = os.path.join(pod_root_dir, "docker-compose.yml")
+                    compose_file_name = os.path.join(pod_root_dir, f"docker-compose-{pod_name}.yml")
                     pod_pre_start_command = pod["pre_start_command"]
                     pod_post_start_command = pod["post_start_command"]
                     if pod_pre_start_command is not None:

app/deploy/deployer.py

@@ -14,6 +14,7 @@
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
 from abc import ABC, abstractmethod
+from pathlib import Path
 
 
 class Deployer(ABC):
@@ -35,7 +36,7 @@ class Deployer(ABC):
         pass
 
     @abstractmethod
-    def execute(self, service_name, command, envs):
+    def execute(self, service_name, command, tty, envs):
         pass
 
     @abstractmethod
@@ -50,3 +51,10 @@ class Deployer(ABC):
 class DeployerException(Exception):
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
+
+
+class DeployerConfigGenerator(ABC):
+
+    @abstractmethod
+    def generate(self, deployment_dir: Path):
+        pass

app/deploy/deployer_factory.py

@@ -13,11 +13,20 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
-from app.deploy.k8s.deploy_k8s import K8sDeployer
-from app.deploy.compose.deploy_docker import DockerDeployer
+from app.deploy.k8s.deploy_k8s import K8sDeployer, K8sDeployerConfigGenerator
+from app.deploy.compose.deploy_docker import DockerDeployer, DockerDeployerConfigGenerator
 
 
-def getDeployer(type, compose_files, compose_project_name, compose_env_file):
+def getDeployerConfigGenerator(type: str):
+    if type == "compose" or type is None:
+        return DockerDeployerConfigGenerator()
+    elif type == "k8s":
+        return K8sDeployerConfigGenerator()
+    else:
+        print(f"ERROR: deploy-to {type} is not valid")
+
+
+def getDeployer(type: str, compose_files, compose_project_name, compose_env_file):
     if type == "compose" or type is None:
         return DockerDeployer(compose_files, compose_project_name, compose_env_file)
     elif type == "k8s":

app/deploy/deployment_create.py

@@ -22,8 +22,9 @@ import random
 from shutil import copy, copyfile, copytree
 import sys
 from app.util import (get_stack_file_path, get_parsed_deployment_spec, get_parsed_stack_config, global_options, get_yaml,
-                      get_pod_list, get_pod_file_path, pod_has_scripts, get_pod_script_paths, get_plugin_code_path)
+                      get_pod_list, get_pod_file_path, pod_has_scripts, get_pod_script_paths, get_plugin_code_paths)
 from app.deploy.deploy_types import DeploymentContext, DeployCommandContext, LaconicStackSetupCommand
+from app.deploy.deployer_factory import getDeployerConfigGenerator
 
 
 def _make_default_deployment_dir():
@@ -106,9 +107,10 @@ def _fixup_pod_file(pod, spec, compose_dir):
                 pod["services"][container_name]["ports"] = container_ports
 
 
-def _commands_plugin_path(ctx: DeployCommandContext):
-    plugin_path = get_plugin_code_path(ctx.stack)
-    return plugin_path.joinpath("deploy", "commands.py")
+def _commands_plugin_paths(ctx: DeployCommandContext):
+    plugin_paths = get_plugin_code_paths(ctx.stack)
+    ret = [p.joinpath("deploy", "commands.py") for p in plugin_paths]
+    return ret
 
 
 # See: https://stackoverflow.com/a/54625079/1701505
@@ -120,15 +122,23 @@ def call_stack_deploy_init(deploy_command_context):
     # Link with the python file in the stack
     # Call a function in it
     # If no function found, return None
-    python_file_path = _commands_plugin_path(deploy_command_context)
-    if python_file_path.exists():
-        spec = util.spec_from_file_location("commands", python_file_path)
-        imported_stack = util.module_from_spec(spec)
-        spec.loader.exec_module(imported_stack)
-        if _has_method(imported_stack, "init"):
-            return imported_stack.init(deploy_command_context)
-    else:
-        return None
+    python_file_paths = _commands_plugin_paths(deploy_command_context)
+
+    ret = None
+    init_done = False
+    for python_file_path in python_file_paths:
+        if python_file_path.exists():
+            spec = util.spec_from_file_location("commands", python_file_path)
+            imported_stack = util.module_from_spec(spec)
+            spec.loader.exec_module(imported_stack)
+            if _has_method(imported_stack, "init"):
+                if not init_done:
+                    ret = imported_stack.init(deploy_command_context)
+                    init_done = True
+                else:
+                    # TODO: remove this restriction
+                    print(f"Skipping init() from plugin {python_file_path}. Only one init() is allowed.")
+    return ret
 
 
 # TODO: fold this with function above
@@ -136,16 +146,14 @@ def call_stack_deploy_setup(deploy_command_context, parameters: LaconicStackSetu
     # Link with the python file in the stack
     # Call a function in it
     # If no function found, return None
-    python_file_path = _commands_plugin_path(deploy_command_context)
-    print(f"Path: {python_file_path}")
-    if python_file_path.exists():
-        spec = util.spec_from_file_location("commands", python_file_path)
-        imported_stack = util.module_from_spec(spec)
-        spec.loader.exec_module(imported_stack)
-        if _has_method(imported_stack, "setup"):
-            return imported_stack.setup(deploy_command_context, parameters, extra_args)
-    else:
-        return None
+    python_file_paths = _commands_plugin_paths(deploy_command_context)
+    for python_file_path in python_file_paths:
+        if python_file_path.exists():
+            spec = util.spec_from_file_location("commands", python_file_path)
+            imported_stack = util.module_from_spec(spec)
+            spec.loader.exec_module(imported_stack)
+            if _has_method(imported_stack, "setup"):
+                imported_stack.setup(deploy_command_context, parameters, extra_args)
 
 
 # TODO: fold this with function above
@@ -153,15 +161,14 @@ def call_stack_deploy_create(deployment_context, extra_args):
     # Link with the python file in the stack
     # Call a function in it
     # If no function found, return None
-    python_file_path = _commands_plugin_path(deployment_context.command_context)
-    if python_file_path.exists():
-        spec = util.spec_from_file_location("commands", python_file_path)
-        imported_stack = util.module_from_spec(spec)
-        spec.loader.exec_module(imported_stack)
-        if _has_method(imported_stack, "create"):
-            return imported_stack.create(deployment_context, extra_args)
-    else:
-        return None
+    python_file_paths = _commands_plugin_paths(deployment_context.command_context)
+    for python_file_path in python_file_paths:
+        if python_file_path.exists():
+            spec = util.spec_from_file_location("commands", python_file_path)
+            imported_stack = util.module_from_spec(spec)
+            spec.loader.exec_module(imported_stack)
+            if _has_method(imported_stack, "create"):
+                imported_stack.create(deployment_context, extra_args)
 
 
 # Inspect the pod yaml to find config files referenced in subdirectories
@@ -255,7 +262,7 @@ def init(ctx, config, output, map_ports_to_host):
     config_variables = _parse_config_variables(config)
     if config_variables:
         # Implement merge, since update() overwrites
-        orig_config = spec_file_content["config"]
+        orig_config = spec_file_content.get("config", {})
         new_config = config_variables["config"]
         merged_config = {**new_config, **orig_config}
         spec_file_content.update({"config": merged_config})
@@ -336,7 +343,7 @@ def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
         if global_options(ctx).debug:
             print(f"extra config dirs: {extra_config_dirs}")
         _fixup_pod_file(parsed_pod_file, parsed_spec, destination_compose_dir)
-        with open(os.path.join(destination_compose_dir, os.path.basename(pod_file_path)), "w") as output_file:
+        with open(os.path.join(destination_compose_dir, "docker-compose-%s.yml" % pod), "w") as output_file:
             yaml.dump(parsed_pod_file, output_file)
         # Copy the config files for the pod, if any
         config_dirs = {pod}
@@ -360,6 +367,10 @@ def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
     deployment_command_context = ctx.obj
     deployment_command_context.stack = stack_name
     deployment_context = DeploymentContext(Path(deployment_dir), deployment_command_context)
+    # Call the deployer to generate any deployer-specific files (e.g. for kind)
+    deployer_config_generator = getDeployerConfigGenerator(parsed_spec["deploy-to"])
+    # TODO: make deployment_dir a Path above
+    deployer_config_generator.generate(Path(deployment_dir))
     call_stack_deploy_create(deployment_context, [network_dir, initial_peers])
 
 

app/deploy/k8s/cluster_info.py

@@ -17,7 +17,8 @@ from kubernetes import client
 from typing import Any, List, Set
 
 from app.opts import opts
-from app.util import get_yaml
+from app.deploy.k8s.helpers import named_volumes_from_pod_files, volume_mounts_for_service, volumes_for_pod_files
+from app.deploy.k8s.helpers import parsed_pod_files_map_from_file_names
 
 
 class ClusterInfo:
@@ -30,12 +31,7 @@ class ClusterInfo:
         pass
 
     def int_from_pod_files(self, pod_files: List[str]):
-        for pod_file in pod_files:
-            with open(pod_file, "r") as pod_file_descriptor:
-                parsed_pod_file = get_yaml().load(pod_file_descriptor)
-                self.parsed_pod_yaml_map[pod_file] = parsed_pod_file
-        if opts.o.debug:
-            print(f"parsed_pod_yaml_map: {self.parsed_pod_yaml_map}")
+        self.parsed_pod_yaml_map = parsed_pod_files_map_from_file_names(pod_files)
         # Find the set of images in the pods
         for pod_name in self.parsed_pod_yaml_map:
             pod = self.parsed_pod_yaml_map[pod_name]
@@ -47,6 +43,28 @@ class ClusterInfo:
         if opts.o.debug:
             print(f"image_set: {self.image_set}")
 
+    def get_pvcs(self):
+        result = []
+        volumes = named_volumes_from_pod_files(self.parsed_pod_yaml_map)
+        if opts.o.debug:
+            print(f"Volumes: {volumes}")
+        for volume_name in volumes:
+            spec = client.V1PersistentVolumeClaimSpec(
+                storage_class_name="standard",
+                access_modes=["ReadWriteOnce"],
+                resources=client.V1ResourceRequirements(
+                    requests={"storage": "2Gi"}
+                )
+            )
+            pvc = client.V1PersistentVolumeClaim(
+                metadata=client.V1ObjectMeta(name=volume_name,
+                                             labels={"volume-label": volume_name}),
+                spec=spec,
+            )
+            result.append(pvc)
+        return result
+
+    # to suit the deployment, and also annotate the container specs to point at said volumes
     def get_deployment(self):
         containers = []
         for pod_name in self.parsed_pod_yaml_map:
@@ -56,19 +74,22 @@ class ClusterInfo:
                 container_name = service_name
                 service_info = services[service_name]
                 image = service_info["image"]
+                volume_mounts = volume_mounts_for_service(self.parsed_pod_yaml_map, service_name)
                 container = client.V1Container(
                     name=container_name,
                     image=image,
                     ports=[client.V1ContainerPort(container_port=80)],
+                    volume_mounts=volume_mounts,
                     resources=client.V1ResourceRequirements(
                         requests={"cpu": "100m", "memory": "200Mi"},
                         limits={"cpu": "500m", "memory": "500Mi"},
                     ),
                 )
                 containers.append(container)
+        volumes = volumes_for_pod_files(self.parsed_pod_yaml_map)
         template = client.V1PodTemplateSpec(
             metadata=client.V1ObjectMeta(labels={"app": self.app_name}),
-            spec=client.V1PodSpec(containers=containers),
+            spec=client.V1PodSpec(containers=containers, volumes=volumes),
         )
         spec = client.V1DeploymentSpec(
             replicas=1, template=template, selector={

app/deploy/k8s/deploy_k8s.py

@@ -13,11 +13,12 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
+from pathlib import Path
 from kubernetes import client, config
 
-from app.deploy.deployer import Deployer
+from app.deploy.deployer import Deployer, DeployerConfigGenerator
 from app.deploy.k8s.helpers import create_cluster, destroy_cluster, load_images_into_kind
-from app.deploy.k8s.helpers import pods_in_deployment, log_stream_from_string
+from app.deploy.k8s.helpers import pods_in_deployment, log_stream_from_string, generate_kind_config
 from app.deploy.k8s.cluster_info import ClusterInfo
 from app.opts import opts
 
@@ -26,6 +27,7 @@ class K8sDeployer(Deployer):
     name: str = "k8s"
     core_api: client.CoreV1Api
     apps_api: client.AppsV1Api
+    k8s_namespace: str = "default"
     kind_cluster_name: str
     cluster_info : ClusterInfo
 
@@ -45,21 +47,32 @@ class K8sDeployer(Deployer):
 
     def up(self, detach, services):
         # Create the kind cluster
-        create_cluster(self.kind_cluster_name)
+        # HACK: pass in the config file path here
+        create_cluster(self.kind_cluster_name, "./test-deployment-dir/kind-config.yml")
         self.connect_api()
         # Ensure the referenced containers are copied into kind
         load_images_into_kind(self.kind_cluster_name, self.cluster_info.image_set)
+        # Figure out the PVCs for this deployment
+        pvcs = self.cluster_info.get_pvcs()
+        for pvc in pvcs:
+            if opts.o.debug:
+                print(f"Sending this: {pvc}")
+            pvc_resp = self.core_api.create_namespaced_persistent_volume_claim(body=pvc, namespace=self.k8s_namespace)
+            if opts.o.debug:
+                print("PVCs created:")
+                print(f"{pvc_resp}")
         # Process compose files into a Deployment
         deployment = self.cluster_info.get_deployment()
         # Create the k8s objects
-        resp = self.apps_api.create_namespaced_deployment(
-            body=deployment, namespace="default"
-        )
-
         if opts.o.debug:
-            print("Deployment created.\n")
-            print(f"{resp.metadata.namespace} {resp.metadata.name} \
-                  {resp.metadata.generation} {resp.spec.template.spec.containers[0].image}")
+            print(f"Sending this: {deployment}")
+        deployment_resp = self.apps_api.create_namespaced_deployment(
+            body=deployment, namespace=self.k8s_namespace
+        )
+        if opts.o.debug:
+            print("Deployment created:")
+            print(f"{deployment_resp.metadata.namespace} {deployment_resp.metadata.name} \
+                  {deployment_resp.metadata.generation} {deployment_resp.spec.template.spec.containers[0].image}")
 
     def down(self, timeout, volumes):
         # Delete the k8s objects
@@ -81,7 +94,7 @@ class K8sDeployer(Deployer):
         # Also look into whether it makes sense to get ports for k8s
         pass
 
-    def execute(self, service_name, command, envs):
+    def execute(self, service_name, command, tty, envs):
         # Call the API to execute a command in a running container
         pass
 
@@ -97,3 +110,19 @@ class K8sDeployer(Deployer):
     def run(self, image, command, user, volumes, entrypoint=None):
         # We need to figure out how to do this -- check why we're being called first
         pass
+
+
+class K8sDeployerConfigGenerator(DeployerConfigGenerator):
+    config_file_name: str = "kind-config.yml"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def generate(self, deployment_dir: Path):
+        # Check the file isn't already there
+        # Get the config file contents
+        content = generate_kind_config(deployment_dir)
+        config_file = deployment_dir.joinpath(self.config_file_name)
+        # Write the file
+        with open(config_file, "w") as output_file:
+            output_file.write(content)

app/deploy/k8s/helpers.py

@@ -14,10 +14,12 @@
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
 from kubernetes import client
+from pathlib import Path
 import subprocess
-from typing import Set
+from typing import Any, Set
 
 from app.opts import opts
+from app.util import get_yaml
 
 
 def _run_command(command: str):
@@ -28,8 +30,8 @@ def _run_command(command: str):
         print(f"Result: {result}")
 
 
-def create_cluster(name: str):
-    _run_command(f"kind create cluster --name {name}")
+def create_cluster(name: str, config_file: str):
+    _run_command(f"kind create cluster --name {name} --config {config_file}")
 
 
 def destroy_cluster(name: str):
@@ -55,3 +57,156 @@ def pods_in_deployment(core_api: client.CoreV1Api, deployment_name: str):
 def log_stream_from_string(s: str):
     # Note response has to be UTF-8 encoded because the caller expects to decode it
     yield ("ignore", s.encode())
+
+
+def named_volumes_from_pod_files(parsed_pod_files):
+    # Parse the compose files looking for named volumes
+    named_volumes = []
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "volumes" in parsed_pod_file:
+            volumes = parsed_pod_file["volumes"]
+            for volume in volumes.keys():
+                # Volume definition looks like:
+                # 'laconicd-data': None
+                named_volumes.append(volume)
+    return named_volumes
+
+
+def volume_mounts_for_service(parsed_pod_files, service):
+    result = []
+    # Find the service
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "services" in parsed_pod_file:
+            services = parsed_pod_file["services"]
+            for service_name in services:
+                if service_name == service:
+                    service_obj = services[service_name]
+                    if "volumes" in service_obj:
+                        volumes = service_obj["volumes"]
+                        for mount_string in volumes:
+                            # Looks like: test-data:/data
+                            (volume_name, mount_path) = mount_string.split(":")
+                            volume_device = client.V1VolumeMount(mount_path=mount_path, name=volume_name)
+                            result.append(volume_device)
+    return result
+
+
+def volumes_for_pod_files(parsed_pod_files):
+    result = []
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "volumes" in parsed_pod_file:
+            volumes = parsed_pod_file["volumes"]
+            for volume_name in volumes.keys():
+                claim = client.V1PersistentVolumeClaimVolumeSource(claim_name=volume_name)
+                volume = client.V1Volume(name=volume_name, persistent_volume_claim=claim)
+                result.append(volume)
+    return result
+
+
+def _get_host_paths_for_volumes(parsed_pod_files):
+    result = {}
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "volumes" in parsed_pod_file:
+            volumes = parsed_pod_file["volumes"]
+            for volume_name in volumes.keys():
+                volume_definition = volumes[volume_name]
+                host_path = volume_definition["driver_opts"]["device"]
+                result[volume_name] = host_path
+    return result
+
+
+def parsed_pod_files_map_from_file_names(pod_files):
+    parsed_pod_yaml_map : Any = {}
+    for pod_file in pod_files:
+        with open(pod_file, "r") as pod_file_descriptor:
+            parsed_pod_file = get_yaml().load(pod_file_descriptor)
+            parsed_pod_yaml_map[pod_file] = parsed_pod_file
+    if opts.o.debug:
+        print(f"parsed_pod_yaml_map: {parsed_pod_yaml_map}")
+    return parsed_pod_yaml_map
+
+
+def _generate_kind_mounts(parsed_pod_files):
+    volume_definitions = []
+    volume_host_path_map = _get_host_paths_for_volumes(parsed_pod_files)
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "services" in parsed_pod_file:
+            services = parsed_pod_file["services"]
+            for service_name in services:
+                service_obj = services[service_name]
+                if "volumes" in service_obj:
+                    volumes = service_obj["volumes"]
+                    for mount_string in volumes:
+                        # Looks like: test-data:/data
+                        (volume_name, mount_path) = mount_string.split(":")
+                        volume_definitions.append(
+                            f"  - hostPath: {volume_host_path_map[volume_name]}\n    containerPath: /var/local-path-provisioner"
+                            )
+    return (
+        "" if len(volume_definitions) == 0 else (
+            "  extraMounts:\n"
+            f"{''.join(volume_definitions)}"
+        )
+    )
+
+
+def _generate_kind_port_mappings(parsed_pod_files):
+    port_definitions = []
+    for pod in parsed_pod_files:
+        parsed_pod_file = parsed_pod_files[pod]
+        if "services" in parsed_pod_file:
+            services = parsed_pod_file["services"]
+            for service_name in services:
+                service_obj = services[service_name]
+                if "ports" in service_obj:
+                    ports = service_obj["ports"]
+                    for port_string in ports:
+                        # TODO handle the complex cases
+                        # Looks like: 80 or something more complicated
+                        port_definitions.append(f"  - containerPort: {port_string}\n    hostPort: {port_string}")
+    return (
+        "" if len(port_definitions) == 0 else (
+            "  extraPortMappings:\n"
+            f"{''.join(port_definitions)}"
+        )
+    )
+
+
+# This needs to know:
+# The service ports for the cluster
+# The bind mounted volumes for the cluster
+#
+# Make ports like this:
+#  extraPortMappings:
+#  - containerPort: 80
+#    hostPort: 80
+#    # optional: set the bind address on the host
+#    # 0.0.0.0 is the current default
+#    listenAddress: "127.0.0.1"
+#    # optional: set the protocol to one of TCP, UDP, SCTP.
+#    # TCP is the default
+#    protocol: TCP
+# Make bind mounts like this:
+#  extraMounts:
+#  - hostPath: /path/to/my/files
+#    containerPath: /files
+def generate_kind_config(deployment_dir: Path):
+    compose_file_dir = deployment_dir.joinpath("compose")
+    # TODO: this should come from the stack file, not this way
+    pod_files = [p for p in compose_file_dir.iterdir() if p.is_file()]
+    parsed_pod_files_map = parsed_pod_files_map_from_file_names(pod_files)
+    port_mappings_yml = _generate_kind_port_mappings(parsed_pod_files_map)
+    mounts_yml = _generate_kind_mounts(parsed_pod_files_map)
+    return (
+        "kind: Cluster\n"
+        "apiVersion: kind.x-k8s.io/v1alpha4\n"
+        "nodes:\n"
+        "- role: control-plane\n"
+        f"{port_mappings_yml}\n"
+        f"{mounts_yml}\n"
+    )

app/util.py

@@ -79,16 +79,16 @@ def get_pod_list(parsed_stack):
     return result
 
 
-def get_plugin_code_path(stack):
+def get_plugin_code_paths(stack):
     parsed_stack = get_parsed_stack_config(stack)
     pods = parsed_stack["pods"]
-    # TODO: Hack
-    pod = pods[0]
-    if type(pod) is str:
-        result = get_stack_file_path(stack).parent
-    else:
-        pod_root_dir = os.path.join(get_dev_root_path(None), pod["repository"].split("/")[-1], pod["path"])
-        result = Path(os.path.join(pod_root_dir, "stack"))
+    result = []
+    for pod in pods:
+        if type(pod) is str:
+            result.append(get_stack_file_path(stack).parent)
+        else:
+            pod_root_dir = os.path.join(get_dev_root_path(None), pod["repository"].split("/")[-1], pod["path"])
+            result.append(Path(os.path.join(pod_root_dir, "stack")))
     return result
 
 

tests/fixturenet-laconicd/run-test.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+set -e
+if [ -n "$CERC_SCRIPT_DEBUG" ]; then
+  set -x
+fi
+
+echo "$(date +"%Y-%m-%d %T"): Running stack-orchestrator Laconicd fixturenet test"
+env
+cat /etc/hosts
+# Bit of a hack, test the most recent package
+TEST_TARGET_SO=$( ls -t1 ./package/laconic-so* | head -1 )
+# Set a new unique repo dir
+export CERC_REPO_BASE_DIR=$(mktemp -d $(pwd)/stack-orchestrator-fixturenet-laconicd-test.XXXXXXXXXX)
+echo "$(date +"%Y-%m-%d %T"): Testing this package: $TEST_TARGET_SO"
+echo "$(date +"%Y-%m-%d %T"): Test version command"
+reported_version_string=$( $TEST_TARGET_SO version )
+echo "$(date +"%Y-%m-%d %T"): Version reported is: ${reported_version_string}"
+
+echo "$(date +"%Y-%m-%d %T"): Cloning laconicd repositories into: $CERC_REPO_BASE_DIR"
+$TEST_TARGET_SO --stack fixturenet-laconicd setup-repositories
+
+echo "$(date +"%Y-%m-%d %T"): Building containers"
+$TEST_TARGET_SO --stack fixturenet-laconicd build-containers
+echo "$(date +"%Y-%m-%d %T"): Starting stack"
+$TEST_TARGET_SO --stack fixturenet-laconicd deploy --cluster laconicd up
+echo "$(date +"%Y-%m-%d %T"): Stack started"
+# Verify that the fixturenet is up and running
+$TEST_TARGET_SO --stack fixturenet-laconicd deploy --cluster laconicd ps
+
+timeout=900 # 15 minutes
+echo "$(date +"%Y-%m-%d %T"): Getting initial block number. Timeout set to $timeout seconds"
+start_time=$(date +%s)
+elapsed_time=0
+initial_block_number=null
+while [ "$initial_block_number" == "null" ]  && [ $elapsed_time -lt $timeout ]; do
+  sleep 10
+  echo "$(date +"%Y-%m-%d %T"): Waiting for initial block..."
+  initial_block_number=$(docker exec laconicd-laconicd-1 /usr/bin/laconicd status | jq -r .SyncInfo.latest_block_height)
+  current_time=$(date +%s)
+  elapsed_time=$((current_time - start_time))
+done
+
+subsequent_block_number=$initial_block_number
+
+# if initial block was 0 after timeout, assume chain did not start successfully and skip finding subsequent block
+if [[ $initial_block_number != "null" ]]; then
+  timeout=300
+  echo "$(date +"%Y-%m-%d %T"): Getting subsequent block number. Timeout set to $timeout seconds"
+  start_time=$(date +%s)
+  elapsed_time=0
+  # wait for 5 blocks or timeout
+  while [ "$subsequent_block_number" -le $((initial_block_number + 5)) ]  && [ $elapsed_time -lt $timeout ]; do
+    sleep 10
+    echo "$(date +"%Y-%m-%d %T"): Waiting for five blocks or $timeout seconds..."
+    subsequent_block_number=$(docker exec laconicd-laconicd-1 /usr/bin/laconicd status | jq -r .SyncInfo.latest_block_height)
+    current_time=$(date +%s)
+    elapsed_time=$((current_time - start_time))
+  done
+fi
+
+# will return 0 if either of the above loops timed out
+block_number_difference=$((subsequent_block_number - initial_block_number))
+
+echo "$(date +"%Y-%m-%d %T"): Results of block height queries:"
+echo "Initial block height: $initial_block_number"
+echo "Subsequent block height: $subsequent_block_number"
+
+# Block height difference should be between 1 and some small number
+if [[ $block_number_difference -gt 1 && $block_number_difference -lt 100 ]]; then
+  echo "Test passed"
+  test_result=0
+else
+  echo "Test failed: block numbers were ${initial_block_number} and ${subsequent_block_number}"
+  echo "Logs from stack:"
+  $TEST_TARGET_SO --stack fixturenet-laconicd deploy logs
+  test_result=1
+fi
+
+$TEST_TARGET_SO --stack fixturenet-laconicd deploy --cluster laconicd down --delete-volumes
+echo "$(date +"%Y-%m-%d %T"): Removing cloned repositories"
+rm -rf $CERC_REPO_BASE_DIR
+echo "$(date +"%Y-%m-%d %T"): Test finished"
+exit $test_result