update fixturenet-plugeth test

.github/workflows/fixturenet-plugeth.yml

@@ -0,0 +1,30 @@
+name: Fixturenet-Plugeth Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.github/workflows/triggers/fixturenet-plugeth-test'
+
+jobs:
+  test:
+    name: "Run fixturenet-plugeth 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-plugeth tests"
+        run: ./tests/fixturenet-plugeth/run-test.sh

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

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

app/deploy/compose/deploy_docker.py

@@ -13,9 +13,8 @@
 # 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, DeployerConfigGenerator
+from app.deploy.deployer import Deployer, DeployerException
 
 
 class DockerDeployer(Deployer):
@@ -66,14 +65,3 @@ 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

@@ -151,7 +151,7 @@ def exec_operation(ctx, extra_args):
         if global_context.verbose:
             print(f"Running compose exec {service_name} {command_to_exec}")
         try:
-            ctx.obj.deployer.execute(service_name, command_to_exec, envs=container_exec_env)
+            ctx.obj.deployer.execute(service_name, command_to_exec, tty=True, envs=container_exec_env)
         except DeployerException:
             print("container command returned error exit status")
 

app/deploy/deployer.py

@@ -14,7 +14,6 @@
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.
 
 from abc import ABC, abstractmethod
-from pathlib import Path
 
 
 class Deployer(ABC):
@@ -51,10 +50,3 @@ 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,20 +13,11 @@
 # 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, K8sDeployerConfigGenerator
-from app.deploy.compose.deploy_docker import DockerDeployer, DockerDeployerConfigGenerator
+from app.deploy.k8s.deploy_k8s import K8sDeployer
+from app.deploy.compose.deploy_docker import DockerDeployer
 
 
-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):
+def getDeployer(type, 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

@@ -24,7 +24,6 @@ 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_paths)
 from app.deploy.deploy_types import DeploymentContext, DeployCommandContext, LaconicStackSetupCommand
-from app.deploy.deployer_factory import getDeployerConfigGenerator
 
 
 def _make_default_deployment_dir():
@@ -367,10 +366,6 @@ 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,8 +17,7 @@ from kubernetes import client
 from typing import Any, List, Set
 
 from app.opts import opts
-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
+from app.util import get_yaml
 
 
 class ClusterInfo:
@@ -31,7 +30,12 @@ class ClusterInfo:
         pass
 
     def int_from_pod_files(self, pod_files: List[str]):
-        self.parsed_pod_yaml_map = parsed_pod_files_map_from_file_names(pod_files)
+        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}")
         # 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]
@@ -43,28 +47,6 @@ 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:
@@ -74,22 +56,19 @@ 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, volumes=volumes),
+            spec=client.V1PodSpec(containers=containers),
         )
         spec = client.V1DeploymentSpec(
             replicas=1, template=template, selector={

app/deploy/k8s/deploy_k8s.py

@@ -13,12 +13,11 @@
 # 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, DeployerConfigGenerator
+from app.deploy.deployer import Deployer
 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, generate_kind_config
+from app.deploy.k8s.helpers import pods_in_deployment, log_stream_from_string
 from app.deploy.k8s.cluster_info import ClusterInfo
 from app.opts import opts
 
@@ -27,7 +26,6 @@ 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
 
@@ -47,32 +45,21 @@ class K8sDeployer(Deployer):
 
     def up(self, detach, services):
         # Create the kind cluster
-        # HACK: pass in the config file path here
-        create_cluster(self.kind_cluster_name, "./test-deployment-dir/kind-config.yml")
+        create_cluster(self.kind_cluster_name)
         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
-        if opts.o.debug:
-            print(f"Sending this: {deployment}")
-        deployment_resp = self.apps_api.create_namespaced_deployment(
-            body=deployment, namespace=self.k8s_namespace
+        resp = self.apps_api.create_namespaced_deployment(
+            body=deployment, namespace="default"
         )
+
         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}")
+            print("Deployment created.\n")
+            print(f"{resp.metadata.namespace} {resp.metadata.name} \
+                  {resp.metadata.generation} {resp.spec.template.spec.containers[0].image}")
 
     def down(self, timeout, volumes):
         # Delete the k8s objects
@@ -110,19 +97,3 @@ 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,12 +14,10 @@
 # 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 Any, Set
+from typing import Set
 
 from app.opts import opts
-from app.util import get_yaml
 
 
 def _run_command(command: str):
@@ -30,8 +28,8 @@ def _run_command(command: str):
         print(f"Result: {result}")
 
 
-def create_cluster(name: str, config_file: str):
-    _run_command(f"kind create cluster --name {name} --config {config_file}")
+def create_cluster(name: str):
+    _run_command(f"kind create cluster --name {name}")
 
 
 def destroy_cluster(name: str):
@@ -57,156 +55,3 @@ 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"
-    )

tests/fixturenet-eth-plugeth/run-test.sh

@@ -24,21 +24,58 @@ echo "Deploying the cluster"
 $TEST_TARGET_SO --stack $CERC_STACK_NAME deploy up
 # Verify that the fixturenet is up and running
 $TEST_TARGET_SO --stack $CERC_STACK_NAME deploy ps
-$TEST_TARGET_SO --stack $CERC_STACK_NAME deploy exec fixturenet-eth-bootnode-lighthouse /scripts/status-internal.sh
-initial_block_number=$($TEST_TARGET_SO --stack fixturenet-plugeth-tx deploy exec foundry "cast block-number")
-# Check that the block number increases some time later
-sleep 12
-subsequent_block_number=$($TEST_TARGET_SO  --stack $CERC_STACK_NAME deploy exec foundry "cast block-number")
+# $TEST_TARGET_SO --stack $CERC_STACK_NAME deploy exec fixturenet-eth-bootnode-lighthouse /scripts/status-internal.sh
+
+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=0
+while [ "$initial_block_number" -eq 0 ] && [ $elapsed_time -lt $timeout ]; do
+  sleep 10
+  echo "$(date +"%Y-%m-%d %T"): Waiting for initial block..."
+  initial_block_number=$($TEST_TARGET_SO --stack $CERC_STACK_NAME deploy exec foundry "cast block-number")
+  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 -gt 0 ]]; 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=$($TEST_TARGET_SO --stack $CERC_STACK_NAME deploy exec foundry "cast block-number")
+    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 10 ]]; then
+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 $CERC_STACK_NAME deploy logs
   test_result=1
 fi
-$TEST_TARGET_SO --stack $CERC_STACK_NAME deploy down
+
+$TEST_TARGET_SO --stack $CERC_STACK_NAME deploy down --delete-volumes
 echo "Removing cloned repositories"
 rm -rf $CERC_REPO_BASE_DIR
 exit $test_result