Allow payment reuse for same app LRN (#961)

Part of [Service provider auctions for web deployments](https://www.notion.so/Service-provider-auctions-for-web-deployments-104a6b22d47280dbad51d28aa3a91d75)

Reviewed-on: cerc-io/stack-orchestrator#961
Reviewed-by: ashwin <ashwin@noreply.git.vdb.to>
Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>
Co-committed-by: Prathamesh Musale <prathamesh.musale0@gmail.com>

.gitea/workflows/fixturenet-eth-plugeth-test.yml

@@ -1,36 +0,0 @@
-name: Fixturenet-Eth-Plugeth-Test
-
-on:
-  push:
-    branches: 'ci-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 Ethereum plugeth fixturenet test"
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Clone project repository"
-        uses: actions/checkout@v3
-      - name: "Install Python"
-        uses: cerc-io/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-eth tests"
-        run: ./tests/fixturenet-eth-plugeth/run-test.sh

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

@@ -0,0 +1,66 @@
+name: Fixturenet-Laconicd-Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/fixturenet-laconicd-test'
+  schedule:
+    - cron: '1 13 * * *'
+
+jobs:
+  test:
+    name: "Run Laconicd fixturenet and Laconic CLI tests"
+    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==1.0.6
+      - 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
+      - name: "Run laconic CLI tests"
+        run: ./tests/fixturenet-laconicd/run-cli-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/lint.yml

@@ -0,0 +1,37 @@
+name: Lint Checks
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run linter"
+    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 : "Run flake8"
+        uses: py-actions/flake8@v2
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/publish.yml

@@ -5,6 +5,8 @@ on:
     branches:
       - main
       - publish-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
 jobs:
   publish:
@@ -18,14 +20,22 @@ jobs:
         run: |
           build_tag=$(./scripts/create_build_tag_file.sh)
           echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
-      - name: "Install Python"
+      # 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
+        run: pip install shiv==1.0.6
       - name: "Build local shiv package"
         id: build
         run: |
@@ -44,3 +54,19 @@ jobs:
           # Hack using endsWith to workaround Gitea sometimes sending "publish-test" vs "refs/heads/publish-test"
           draft: ${{ endsWith('publish-test', github.ref ) }}
           files: ./laconic-so
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-container-registry.yml

@@ -0,0 +1,69 @@
+name: Container Registry Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-container-registry'
+      - '.gitea/workflows/test-container-registry.yml'
+      - 'tests/container-registry/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '6 19 * * *'
+
+jobs:
+  test:
+    name: "Run contaier registry hosting test on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - 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==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Install ed" # Only needed until we remove the need to edit the spec file
+        run: apt update && apt install -y ed
+      - name: "Run container registry deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/container-registry/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-database.yml

@@ -0,0 +1,67 @@
+name: Database Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-database'
+      - '.gitea/workflows/test-database.yml'
+      - 'tests/database/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '5 18 * * *'
+
+jobs:
+  test:
+    name: "Run database hosting test on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - 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==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run database deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/database/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-deploy.yml

@@ -7,10 +7,9 @@ on:
     branches:
       - main
       - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
-# Needed until we can incorporate docker startup into the executor container
-env:
-  DOCKER_HOST: unix:///var/run/dind.sock
 
 jobs:
   test:
@@ -19,21 +18,41 @@ jobs:
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
+      # 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
+        run: pip install shiv==1.0.6
       - 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 deploy tests"
         run: ./tests/deploy/run-deploy-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-external-stack.yml

@@ -0,0 +1,58 @@
+name: External Stack Test
+
+on:
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-external-stack'
+      - '.gitea/workflows/test-external-stack.yml'
+      - 'tests/external-stack/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '8 19 * * *'
+
+jobs:
+  test:
+    name: "Run external stack test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - 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==1.0.6
+      - 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 external stack tests"
+        run: ./tests/external-stack/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-k8s-deploy.yml

@@ -0,0 +1,69 @@
+name: K8s Deploy Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-k8s-deploy'
+      - '.gitea/workflows/test-k8s-deploy.yml'
+      - 'tests/k8s-deploy/run-deploy-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '3 15 * * *'
+
+jobs:
+  test:
+    name: "Run deploy test suite on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - 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==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run k8s deployment test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/k8s-deploy/run-deploy-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-k8s-deployment-control.yml

@@ -0,0 +1,69 @@
+name: K8s Deployment Control Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+    paths:
+      - '!**'
+      - '.gitea/workflows/triggers/test-k8s-deployment-control'
+      - '.gitea/workflows/test-k8s-deployment-control.yml'
+      - 'tests/k8s-deployment-control/run-test.sh'
+  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
+    - cron: '3 30 * * *'
+
+jobs:
+  test:
+    name: "Run deployment control suite on kind/k8s"
+    runs-on: ubuntu-22.04
+    steps:
+      - 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==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Check cgroups version"
+        run: mount | grep cgroup
+      - name: "Install kind"
+        run: ./tests/scripts/install-kind.sh
+      - name: "Install Kubectl"
+        run: ./tests/scripts/install-kubectl.sh
+      - name: "Run k8s deployment control test"
+        run: |
+          source /opt/bash-utils/cgroup-helper.sh
+          join_cgroup
+          ./tests/k8s-deployment-control/run-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test-webapp.yml

@@ -0,0 +1,59 @@
+name: Webapp Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches:
+      - main
+      - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
+
+jobs:
+  test:
+    name: "Run webapp test suite"
+    runs-on: ubuntu-latest
+    steps:
+      - 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==1.0.6
+      - name: "Generate build version file"
+        run: ./scripts/create_build_tag_file.sh
+      - name: "Build local shiv package"
+        run: ./scripts/build_shiv_package.sh
+      - name: "Install wget" # 20240109 - Only needed until the executors are updated.
+        run: apt update && apt install -y wget
+      - name: "Run webapp tests"
+        run: ./tests/webapp-test/run-webapp-test.sh
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

.gitea/workflows/test.yml

@@ -7,10 +7,9 @@ on:
     branches:
       - main
       - ci-test
+    paths-ignore:
+      - '.gitea/workflows/triggers/*'
 
-# Needed until we can incorporate docker startup into the executor container
-env:
-  DOCKER_HOST: unix:///var/run/dind.sock
 
 jobs:
   test:
@@ -19,22 +18,41 @@ jobs:
     steps:
       - name: "Clone project repository"
         uses: actions/checkout@v3
-      - name: "Install Python"
+      # 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
+        run: pip install shiv==1.0.6
       - 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 smoke tests"
         run: ./tests/smoke-test/run-smoke-test.sh
-
+      - name: Notify Vulcanize Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.VULCANIZE_SLACK_CI_ALERTS }}
+      - name: Notify DeepStack Slack on CI failure
+        if: ${{ always() && github.ref_name == 'main' }}
+        uses: ravsamhq/notify-slack-action@v2
+        with:
+          status: ${{ job.status }}
+          notify_when: 'failure'
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.DEEPSTACK_SLACK_CI_ALERTS }}

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

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

.gitea/workflows/triggers/test-container-registry

@@ -0,0 +1 @@
+Change this file to trigger running the test-container-registry CI job

.gitea/workflows/triggers/test-database

@@ -0,0 +1,2 @@
+Change this file to trigger running the test-database CI job
+Trigger test run

.gitea/workflows/triggers/test-external-stack

@@ -0,0 +1,2 @@
+Change this file to trigger running the external-stack CI job
+trigger

.gitea/workflows/triggers/test-k8s-deploy

@@ -0,0 +1,2 @@
+Change this file to trigger running the test-k8s-deploy CI job
+Trigger test on PR branch

.github/workflows/fixturenet-eth.yml

@@ -1,17 +1,15 @@
-name: Fixturenet-Eth-Test
+name: Fixturenet-Eth Test
 
 on:
   push:
-    branches: 'ci-test'
+    branches: '*'
-
+    paths:
-# Needed until we can incorporate docker startup into the executor container
+      - '!**'
-env:
+      - '.github/workflows/triggers/fixturenet-eth-test'
-  DOCKER_HOST: unix:///var/run/dind.sock
-
 
 jobs:
   test:
-    name: "Run an Ethereum fixturenet test"
+    name: "Run fixturenet-eth test suite"
     runs-on: ubuntu-latest
     steps:
       - name: "Clone project repository"
@@ -28,10 +26,5 @@ jobs:
         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-eth tests"
         run: ./tests/fixturenet-eth/run-test.sh
-

.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/test-webapp.yml

@@ -0,0 +1,29 @@
+name: Webapp Test
+
+on:
+  pull_request:
+    branches: '*'
+  push:
+    branches: '*'
+
+jobs:
+  test:
+    name: "Run webapp 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 webapp tests"
+        run: ./tests/webapp-test/run-webapp-test.sh

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

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

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

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

.gitignore

@@ -6,5 +6,5 @@ laconic_stack_orchestrator.egg-info
 __pycache__
 *~
 package
-app/data/build_tag.txt
+stack_orchestrator/data/build_tag.txt
-build
+/build

README.md

@@ -29,10 +29,10 @@ chmod +x ~/.docker/cli-plugins/docker-compose
 Next decide on a directory where you would like to put the stack-orchestrator program. Typically this would be 
 a "user" binary directory such as `~/bin` or perhaps `/usr/local/laconic` or possibly just the current working directory.
 
-Now, having selected that directory, download the latest release from [this page](https://github.com/cerc-io/stack-orchestrator/tags) into it (we're using `~/bin` below for concreteness but edit to suit if you selected a different directory). Also be sure that the destination directory exists and is writable:
+Now, having selected that directory, download the latest release from [this page](https://git.vdb.to/cerc-io/stack-orchestrator/tags) into it (we're using `~/bin` below for concreteness but edit to suit if you selected a different directory). Also be sure that the destination directory exists and is writable:
 
 ```bash
-curl -L -o ~/bin/laconic-so https://github.com/cerc-io/stack-orchestrator/releases/latest/download/laconic-so
+curl -L -o ~/bin/laconic-so https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
 ```
 
 Give it execute permissions:
@@ -49,6 +49,11 @@ Verify operation (your version will probably be different, just check here that
 laconic-so version
 Version: 1.1.0-7a607c2-202304260513
 ```
+Save the distribution url to `~/.laconic-so/config.yml`:
+```bash
+mkdir ~/.laconic-so
+echo "distribution-url: https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so" >  ~/.laconic-so/config.yml
+```
 
 ### Update
 If Stack Orchestrator was installed using the process described above, it is able to subsequently self-update to the current latest version by running:
@@ -59,12 +64,12 @@ laconic-so update
 
 ## Usage
 
-The various [stacks](/app/data/stacks) each contain instructions for running different stacks based on your use case. For example:
+The various [stacks](/stack_orchestrator/data/stacks) each contain instructions for running different stacks based on your use case. For example:
 
-- [self-hosted Gitea](/app/data/stacks/build-support)
+- [self-hosted Gitea](/stack_orchestrator/data/stacks/build-support)
-- [an Optimism Fixturenet](/app/data/stacks/fixturenet-optimism)
+- [an Optimism Fixturenet](/stack_orchestrator/data/stacks/fixturenet-optimism)
-- [laconicd with console and CLI](app/data/stacks/fixturenet-laconic-loaded)
+- [laconicd with console and CLI](stack_orchestrator/data/stacks/fixturenet-laconic-loaded)
-- [kubo (IPFS)](app/data/stacks/kubo)
+- [kubo (IPFS)](stack_orchestrator/data/stacks/kubo)
 
 ## Contributing
 

app/build_containers.py

@@ -1,143 +0,0 @@
-# Copyright © 2022, 2023 Vulcanize
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# 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/>.
-
-# Builds or pulls containers for the system components
-
-# env vars:
-# CERC_REPO_BASE_DIR defaults to ~/cerc
-
-# TODO: display the available list of containers; allow re-build of either all or specific containers
-
-import os
-import sys
-from decouple import config
-import subprocess
-import click
-import importlib.resources
-from pathlib import Path
-from app.util import include_exclude_check, get_parsed_stack_config
-from app.base import get_npm_registry_url
-
-# TODO: find a place for this
-#    epilog="Config provided either in .env or settings.ini or env vars: CERC_REPO_BASE_DIR (defaults to ~/cerc)"
-
-
-@click.command()
-@click.option('--include', help="only build these containers")
-@click.option('--exclude', help="don\'t build these containers")
-@click.option("--force-rebuild", is_flag=True, default=False, help="Override dependency checking -- always rebuild")
-@click.option("--extra-build-args", help="Supply extra arguments to build")
-@click.pass_context
-def command(ctx, include, exclude, force_rebuild, extra_build_args):
-    '''build the set of containers required for a complete stack'''
-
-    quiet = ctx.obj.quiet
-    verbose = ctx.obj.verbose
-    dry_run = ctx.obj.dry_run
-    debug = ctx.obj.debug
-    local_stack = ctx.obj.local_stack
-    stack = ctx.obj.stack
-    continue_on_error = ctx.obj.continue_on_error
-
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    container_build_dir = Path(__file__).absolute().parent.joinpath("data", "container-build")
-
-    if local_stack:
-        dev_root_path = os.getcwd()[0:os.getcwd().rindex("stack-orchestrator")]
-        print(f'Local stack dev_root_path (CERC_REPO_BASE_DIR) overridden to: {dev_root_path}')
-    else:
-        dev_root_path = os.path.expanduser(config("CERC_REPO_BASE_DIR", default="~/cerc"))
-
-    if not quiet:
-        print(f'Dev Root is: {dev_root_path}')
-
-    if not os.path.isdir(dev_root_path):
-        print('Dev root directory doesn\'t exist, creating')
-
-    # See: https://stackoverflow.com/a/20885799/1701505
-    from app import data
-    with importlib.resources.open_text(data, "container-image-list.txt") as container_list_file:
-        all_containers = container_list_file.read().splitlines()
-
-    containers_in_scope = []
-    if stack:
-        stack_config = get_parsed_stack_config(stack)
-        containers_in_scope = stack_config['containers']
-    else:
-        containers_in_scope = all_containers
-
-    if verbose:
-        print(f'Containers: {containers_in_scope}')
-        if stack:
-            print(f"Stack: {stack}")
-
-    # TODO: make this configurable
-    container_build_env = {
-        "CERC_NPM_REGISTRY_URL": get_npm_registry_url(),
-        "CERC_GO_AUTH_TOKEN": config("CERC_GO_AUTH_TOKEN", default=""),
-        "CERC_NPM_AUTH_TOKEN": config("CERC_NPM_AUTH_TOKEN", default=""),
-        "CERC_REPO_BASE_DIR": dev_root_path,
-        "CERC_CONTAINER_BASE_DIR": container_build_dir,
-        "CERC_HOST_UID": f"{os.getuid()}",
-        "CERC_HOST_GID": f"{os.getgid()}",
-        "DOCKER_BUILDKIT": config("DOCKER_BUILDKIT", default="0")
-    }
-    container_build_env.update({"CERC_SCRIPT_DEBUG": "true"} if debug else {})
-    container_build_env.update({"CERC_FORCE_REBUILD": "true"} if force_rebuild else {})
-    container_build_env.update({"CERC_CONTAINER_EXTRA_BUILD_ARGS": extra_build_args} if extra_build_args else {})
-    docker_host_env = os.getenv("DOCKER_HOST")
-    if docker_host_env:
-        container_build_env.update({"DOCKER_HOST": docker_host_env})
-
-    def process_container(container):
-        if not quiet:
-            print(f"Building: {container}")
-        build_dir = os.path.join(container_build_dir, container.replace("/", "-"))
-        build_script_filename = os.path.join(build_dir, "build.sh")
-        if verbose:
-            print(f"Build script filename: {build_script_filename}")
-        if os.path.exists(build_script_filename):
-            build_command = build_script_filename
-        else:
-            if verbose:
-                print(f"No script file found: {build_script_filename}, using default build script")
-            repo_dir = container.split('/')[1]
-            # TODO: make this less of a hack -- should be specified in some metadata somewhere
-            # Check if we have a repo for this container. If not, set the context dir to the container-build subdir
-            repo_full_path = os.path.join(dev_root_path, repo_dir)
-            repo_dir_or_build_dir = repo_full_path if os.path.exists(repo_full_path) else build_dir
-            build_command = os.path.join(container_build_dir, "default-build.sh") + f" {container}:local {repo_dir_or_build_dir}"
-        if not dry_run:
-            if verbose:
-                print(f"Executing: {build_command} with environment: {container_build_env}")
-            build_result = subprocess.run(build_command, shell=True, env=container_build_env)
-            if verbose:
-                print(f"Return code is: {build_result.returncode}")
-            if build_result.returncode != 0:
-                print(f"Error running build for {container}")
-                if not continue_on_error:
-                    print("FATAL Error: container build failed and --continue-on-error not set, exiting")
-                    sys.exit(1)
-                else:
-                    print("****** Container Build Error, continuing because --continue-on-error is set")
-        else:
-            print("Skipped")
-
-    for container in containers_in_scope:
-        if include_exclude_check(container, include, exclude):
-            process_container(container)
-        else:
-            if verbose:
-                print(f"Excluding: {container}")

app/data/compose/docker-compose-kubo.yml

@@ -1,13 +0,0 @@
-version: "3.2"
-# See: https://docs.ipfs.tech/install/run-ipfs-inside-docker/#set-up
-services:
-  ipfs:
-    image: ipfs/kubo:master-2023-02-20-714a968
-    restart: always
-    volumes:
-      - ./ipfs/import:/import
-      - ./ipfs/data:/data/ipfs
-    ports:
-      - "0.0.0.0:8080:8080"
-      - "0.0.0.0:4001:4001"
-      - "0.0.0.0:5001:5001"

app/data/compose/docker-compose-watcher-azimuth.yml

@@ -1,304 +0,0 @@
-version: '3.2'
-
-services:
-  # Starts the PostgreSQL database for watchers
-  watcher-db:
-    restart: unless-stopped
-    image: postgres:14-alpine
-    environment:
-      - POSTGRES_USER=vdbm
-      - POSTGRES_MULTIPLE_DATABASES=azimuth-watcher,azimuth-watcher-job-queue,censures-watcher,censures-watcher-job-queue,claims-watcher,claims-watcher-job-queue,conditional-star-release-watcher,conditional-star-release-watcher-job-queue,delegated-sending-watcher,delegated-sending-watcher-job-queue,ecliptic-watcher,ecliptic-watcher-job-queue,linear-star-release-watcher,linear-star-release-watcher-job-queue,polls-watcher,polls-watcher-job-queue
-      - POSTGRES_EXTENSION=azimuth-watcher-job-queue:pgcrypto,censures-watcher-job-queue:pgcrypto,claims-watcher-job-queue:pgcrypto,conditional-star-release-watcher-job-queue:pgcrypto,delegated-sending-watcher-job-queue:pgcrypto,ecliptic-watcher-job-queue:pgcrypto,linear-star-release-watcher-job-queue:pgcrypto,polls-watcher-job-queue:pgcrypto,
-      - POSTGRES_PASSWORD=password
-    volumes:
-      - ../config/postgresql/multiple-postgressql-databases.sh:/docker-entrypoint-initdb.d/multiple-postgressql-databases.sh
-      - watcher_db_data:/var/lib/postgresql/data
-    ports:
-      - "0.0.0.0:15432:5432"
-    healthcheck:
-      test: ["CMD", "nc", "-v", "localhost", "5432"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 10s
-
-  # Starts the azimuth-watcher server
-  azimuth-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/azimuth-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/azimuth-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/azimuth-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/azimuth-watcher/start-server.sh
-    ports:
-      - "3001"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3001"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the censures-watcher server
-  censures-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/censures-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/censures-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/censures-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/censures-watcher/start-server.sh
-    ports:
-      - "3002"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3002"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the claims-watcher server
-  claims-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/claims-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/claims-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/claims-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/claims-watcher/start-server.sh
-    ports:
-      - "3003"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3003"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the conditional-star-release-watcher server
-  conditional-star-release-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/conditional-star-release-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/conditional-star-release-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/conditional-star-release-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/conditional-star-release-watcher/start-server.sh
-    ports:
-      - "3004"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3004"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the delegated-sending-watcher server
-  delegated-sending-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/delegated-sending-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/delegated-sending-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/delegated-sending-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/delegated-sending-watcher/start-server.sh
-    ports:
-      - "3005"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3005"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the ecliptic-watcher server
-  ecliptic-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/ecliptic-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/ecliptic-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/ecliptic-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/ecliptic-watcher/start-server.sh
-    ports:
-      - "3006"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3006"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the linear-star-release-watcher server
-  linear-star-release-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/linear-star-release-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/linear-star-release-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/linear-star-release-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/linear-star-release-watcher/start-server.sh
-    ports:
-      - "3007"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3007"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the polls-watcher server
-  polls-watcher-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      watcher-db:
-        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
-      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
-    working_dir: /app/packages/polls-watcher
-    command: "./start-server.sh"
-    volumes:
-      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/polls-watcher/environments/watcher-config-template.toml
-      - ../config/watcher-azimuth/merge-toml.js:/app/packages/polls-watcher/merge-toml.js
-      - ../config/watcher-azimuth/start-server.sh:/app/packages/polls-watcher/start-server.sh
-    ports:
-      - "3008"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "3008"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-  # Starts the gateway-server for proxying queries
-  gateway-server:
-    image: cerc/watcher-azimuth:local
-    restart: unless-stopped
-    depends_on:
-      azimuth-watcher-server:
-        condition: service_healthy
-      censures-watcher-server:
-        condition: service_healthy
-      claims-watcher-server:
-        condition: service_healthy
-      conditional-star-release-watcher-server:
-        condition: service_healthy
-      delegated-sending-watcher-server:
-        condition: service_healthy
-      ecliptic-watcher-server:
-        condition: service_healthy
-      linear-star-release-watcher-server:
-        condition: service_healthy
-      polls-watcher-server:
-        condition: service_healthy
-    environment:
-      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
-    working_dir: /app/packages/gateway-server
-    command: "yarn server"
-    volumes:
-      - ../config/watcher-azimuth/gateway-watchers.json:/app/packages/gateway-server/dist/watchers.json
-    ports:
-      - "0.0.0.0:4000:4000"
-    healthcheck:
-      test: ["CMD", "nc", "-vz", "localhost", "4000"]
-      interval: 20s
-      timeout: 5s
-      retries: 15
-      start_period: 5s
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
-
-volumes:
-  watcher_db_data:

app/data/config/fixturenet-laconicd/create-fixturenet.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-# TODO: this file is now an unmodified copy of cerc-io/laconicd/init.sh
-# so we should have a mechanism to bundle it inside the container rather than link from here
-# at deploy time.
-
-KEY="mykey"
-CHAINID="laconic_9000-1"
-MONIKER="localtestnet"
-KEYRING="test"
-KEYALGO="eth_secp256k1"
-LOGLEVEL="info"
-# trace evm
-TRACE="--trace"
-# TRACE=""
-
-# validate dependencies are installed
-command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; }
-
-# remove existing daemon and client
-rm -rf ~/.laconic*
-
-make install
-
-laconicd config keyring-backend $KEYRING
-laconicd config chain-id $CHAINID
-
-# if $KEY exists it should be deleted
-laconicd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO
-
-# Set moniker and chain-id for Ethermint (Moniker can be anything, chain-id must be an integer)
-laconicd init $MONIKER --chain-id $CHAINID
-
-# Change parameter token denominations to aphoton
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["mint"]["params"]["mint_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-# Custom modules
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commit_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveal_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_minimum_bid"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-if [[ "$TEST_REGISTRY_EXPIRY" == "true" ]]; then
-  echo "Setting timers for expiry tests."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-if [[ "$TEST_AUCTION_ENABLED" == "true" ]]; then
-  echo "Enabling auction and setting timers."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_enabled"]=true' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="300s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commits_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveals_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-# increase block time (?)
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["time_iota_ms"]="1000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# Set gas limit in genesis
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="10000000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# disable produce empty block
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-  else
-    sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-fi
-
-if [[ $1 == "pending" ]]; then
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-      sed -i '' 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  else
-      sed -i 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  fi
-fi
-
-# Allocate genesis accounts (cosmos formatted addresses)
-laconicd add-genesis-account $KEY 100000000000000000000000000aphoton --keyring-backend $KEYRING
-
-# Sign genesis transaction
-laconicd gentx $KEY 1000000000000000000000aphoton --keyring-backend $KEYRING --chain-id $CHAINID
-
-# Collect genesis tx
-laconicd collect-gentxs
-
-# Run this to ensure everything worked and that the genesis file is setup correctly
-laconicd validate-genesis
-
-if [[ $1 == "pending" ]]; then
-  echo "pending mode is on, please wait for the first block committed."
-fi
-
-# Start the node (remove the --pruning=nothing flag if historical queries are not needed)
-laconicd start --pruning=nothing --evm.tracer=json $TRACE --log_level $LOGLEVEL --minimum-gas-prices=0.0001aphoton --json-rpc.api eth,txpool,personal,net,debug,web3,miner --api.enable --gql-server --gql-playground

app/data/config/fixturenet-optimism/generate-l2-config.sh

@@ -1,37 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Check existing config if it exists
-if [ -f /app/jwt.txt ] && [ -f /app/rollup.json ]; then
-  echo "Found existing L2 config, cross-checking with L1 deployment config"
-
-  SOURCE_L1_CONF=$(cat /contracts-bedrock/deploy-config/getting-started.json)
-  EXP_L1_BLOCKHASH=$(echo "$SOURCE_L1_CONF" | jq -r '.l1StartingBlockTag')
-  EXP_BATCHER=$(echo "$SOURCE_L1_CONF" | jq -r '.batchSenderAddress')
-
-  GEN_L2_CONF=$(cat /app/rollup.json)
-  GEN_L1_BLOCKHASH=$(echo "$GEN_L2_CONF" | jq -r '.genesis.l1.hash')
-  GEN_BATCHER=$(echo "$GEN_L2_CONF" | jq -r '.genesis.system_config.batcherAddr')
-
-  if [ "$EXP_L1_BLOCKHASH" = "$GEN_L1_BLOCKHASH" ] && [ "$EXP_BATCHER" = "$GEN_BATCHER" ]; then
-    echo "Config cross-checked, exiting"
-    exit 0
-  fi
-
-  echo "Existing L2 config doesn't match the L1 deployment config, please clear L2 config volume before starting"
-  exit 1
-fi
-
-op-node genesis l2 \
-  --deploy-config /contracts-bedrock/deploy-config/getting-started.json \
-  --deployment-dir /contracts-bedrock/deployments/getting-started/ \
-  --outfile.l2 /app/genesis.json \
-  --outfile.rollup /app/rollup.json \
-  --l1-rpc $CERC_L1_RPC
-
-openssl rand -hex 32 > /app/jwt.txt

app/data/config/fixturenet-optimism/optimism-contracts/run.sh

@@ -1,131 +0,0 @@
-#!/bin/bash
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_CHAIN_ID="${CERC_L1_CHAIN_ID:-${DEFAULT_CERC_L1_CHAIN_ID}}"
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-CERC_L1_ACCOUNTS_CSV_URL="${CERC_L1_ACCOUNTS_CSV_URL:-${DEFAULT_CERC_L1_ACCOUNTS_CSV_URL}}"
-
-echo "Using L1 RPC endpoint ${CERC_L1_RPC}"
-
-IMPORT_1="import './verify-contract-deployment'"
-IMPORT_2="import './rekey-json'"
-IMPORT_3="import './send-balance'"
-
-# Append mounted tasks to tasks/index.ts file if not present
-if ! grep -Fxq "$IMPORT_1" tasks/index.ts; then
-  echo "$IMPORT_1" >> tasks/index.ts
-  echo "$IMPORT_2" >> tasks/index.ts
-  echo "$IMPORT_3" >> tasks/index.ts
-fi
-
-# Update the chainId in the hardhat config
-sed -i "/getting-started/ {n; s/.*chainId.*/      chainId: $CERC_L1_CHAIN_ID,/}" hardhat.config.ts
-
-# Exit if a deployment already exists (on restarts)
-# Note: fixturenet-eth-geth currently starts fresh on a restart
-if [ -d "deployments/getting-started" ]; then
-  echo "Deployment directory deployments/getting-started found, checking SystemDictator deployment"
-
-  # Read JSON file into variable
-  SYSTEM_DICTATOR_DETAILS=$(cat deployments/getting-started/SystemDictator.json)
-
-  # Parse JSON into variables
-  SYSTEM_DICTATOR_ADDRESS=$(echo "$SYSTEM_DICTATOR_DETAILS" | jq -r '.address')
-  SYSTEM_DICTATOR_TXHASH=$(echo "$SYSTEM_DICTATOR_DETAILS" | jq -r '.transactionHash')
-
-  if yarn hardhat verify-contract-deployment --contract "${SYSTEM_DICTATOR_ADDRESS}" --transaction-hash "${SYSTEM_DICTATOR_TXHASH}"; then
-    echo "Deployment verfication successful, exiting"
-    exit 0
-  else
-    echo "Deployment verfication failed, please clear L1 deployment volume before starting"
-    exit 1
-  fi
-fi
-
-# Generate the L2 account addresses
-yarn hardhat rekey-json --output /l2-accounts/keys.json
-
-# Read JSON file into variable
-KEYS_JSON=$(cat /l2-accounts/keys.json)
-
-# Parse JSON into variables
-ADMIN_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Admin.address')
-ADMIN_PRIV_KEY=$(echo "$KEYS_JSON" | jq -r '.Admin.privateKey')
-PROPOSER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Proposer.address')
-BATCHER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Batcher.address')
-SEQUENCER_ADDRESS=$(echo "$KEYS_JSON" | jq -r '.Sequencer.address')
-
-# Get the private keys of L1 accounts
-if [ -n "$CERC_L1_ACCOUNTS_CSV_URL" ] && \
-  l1_accounts_response=$(curl -L --write-out '%{http_code}' --silent --output /dev/null "$CERC_L1_ACCOUNTS_CSV_URL") && \
-  [ "$l1_accounts_response" -eq 200 ];
-then
-  echo "Fetching L1 account credentials using provided URL"
-  mkdir -p /geth-accounts
-  wget -O /geth-accounts/accounts.csv "$CERC_L1_ACCOUNTS_CSV_URL"
-
-  CERC_L1_ADDRESS=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 2)
-  CERC_L1_PRIV_KEY=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 3)
-  CERC_L1_ADDRESS_2=$(awk -F, 'NR==2{print $(NF-1)}' /geth-accounts/accounts.csv)
-  CERC_L1_PRIV_KEY_2=$(awk -F, 'NR==2{print $NF}' /geth-accounts/accounts.csv)
-else
-  echo "Couldn't fetch L1 account credentials, using them from env"
-fi
-
-# Send balances to the above L2 addresses
-yarn hardhat send-balance --to "${ADMIN_ADDRESS}" --amount 2 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${PROPOSER_ADDRESS}" --amount 5 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-yarn hardhat send-balance --to "${BATCHER_ADDRESS}" --amount 1000 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-
-echo "Balances sent to L2 accounts"
-
-# Select a finalized L1 block as the starting point for roll ups
-until FINALIZED_BLOCK=$(cast block finalized --rpc-url "$CERC_L1_RPC"); do
-    echo "Waiting for a finalized L1 block to exist, retrying after 10s"
-    sleep 10
-done
-
-L1_BLOCKNUMBER=$(echo "$FINALIZED_BLOCK" | awk '/number/{print $2}')
-L1_BLOCKHASH=$(echo "$FINALIZED_BLOCK" | awk '/hash/{print $2}')
-L1_BLOCKTIMESTAMP=$(echo "$FINALIZED_BLOCK" | awk '/timestamp/{print $2}')
-
-echo "Selected L1 block ${L1_BLOCKNUMBER} as the starting block for roll ups"
-
-# Update the deployment config
-sed -i 's/"l2OutputOracleStartingTimestamp": TIMESTAMP/"l2OutputOracleStartingTimestamp": '"$L1_BLOCKTIMESTAMP"'/g' deploy-config/getting-started.json
-jq --arg chainid "$CERC_L1_CHAIN_ID" '.l1ChainID = ($chainid | tonumber)' deploy-config/getting-started.json > tmp.json && mv tmp.json deploy-config/getting-started.json
-
-node update-config.js deploy-config/getting-started.json "$ADMIN_ADDRESS" "$PROPOSER_ADDRESS" "$BATCHER_ADDRESS" "$SEQUENCER_ADDRESS" "$L1_BLOCKHASH"
-
-echo "Updated the deployment config"
-
-# Create a .env file
-echo "L1_RPC=$CERC_L1_RPC" > .env
-echo "PRIVATE_KEY_DEPLOYER=$ADMIN_PRIV_KEY" >> .env
-
-echo "Deploying the L1 smart contracts, this will take a while..."
-
-# Deploy the L1 smart contracts
-yarn hardhat deploy --network getting-started --tags l1
-
-echo "Deployed the L1 smart contracts"
-
-# Read Proxy contract's JSON and get the address
-PROXY_JSON=$(cat deployments/getting-started/Proxy__OVM_L1StandardBridge.json)
-PROXY_ADDRESS=$(echo "$PROXY_JSON" | jq -r '.address')
-
-# Send balance to the above Proxy contract in L1 for reflecting balance in L2
-# First account
-yarn hardhat send-balance --to "${PROXY_ADDRESS}" --amount 1 --private-key "${CERC_L1_PRIV_KEY}" --network getting-started
-# Second account
-yarn hardhat send-balance --to "${PROXY_ADDRESS}" --amount 1 --private-key "${CERC_L1_PRIV_KEY_2}" --network getting-started
-
-echo "Balance sent to Proxy L2 contract"
-echo "Use following accounts for transactions in L2:"
-echo "${CERC_L1_ADDRESS}"
-echo "${CERC_L1_ADDRESS_2}"
-echo "Done"

app/data/config/fixturenet-optimism/optimism-contracts/update-config.js

@@ -1,36 +0,0 @@
-const fs = require('fs')
-
-// Get the command-line argument
-const configFile = process.argv[2]
-const adminAddress = process.argv[3]
-const proposerAddress = process.argv[4]
-const batcherAddress = process.argv[5]
-const sequencerAddress = process.argv[6]
-const blockHash = process.argv[7]
-
-// Read the JSON file
-const configData = fs.readFileSync(configFile)
-const configObj = JSON.parse(configData)
-
-// Update the finalSystemOwner property with the ADMIN_ADDRESS value
-configObj.finalSystemOwner =
-  configObj.portalGuardian =
-  configObj.controller =
-  configObj.l2OutputOracleChallenger =
-  configObj.proxyAdminOwner =
-  configObj.baseFeeVaultRecipient =
-  configObj.l1FeeVaultRecipient =
-  configObj.sequencerFeeVaultRecipient =
-  configObj.governanceTokenOwner =
-    adminAddress
-
-configObj.l2OutputOracleProposer = proposerAddress
-
-configObj.batchSenderAddress = batcherAddress
-
-configObj.p2pSequencerAddress = sequencerAddress
-
-configObj.l1StartingBlockTag = blockHash
-
-// Write the updated JSON object back to the file
-fs.writeFileSync(configFile, JSON.stringify(configObj, null, 2))

app/data/config/fixturenet-optimism/run-op-geth.sh

@@ -1,90 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-# TODO: Add in container build or use other tool
-echo "Installing jq"
-apk update && apk add jq
-
-# Get Sequencer key from keys.json
-SEQUENCER_KEY=$(jq -r '.Sequencer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-# Initialize op-geth if datadir/geth not found
-if [ -f /op-node/jwt.txt ] && [ -d datadir/geth ]; then
-  echo "Found existing datadir, checking block signer key"
-
-  BLOCK_SIGNER_KEY=$(cat datadir/block-signer-key)
-
-  if [ "$SEQUENCER_KEY" = "$BLOCK_SIGNER_KEY" ]; then
-    echo "Sequencer and block signer keys match, skipping initialization"
-  else
-    echo "Sequencer and block signer keys don't match, please clear L2 geth data volume before starting"
-    exit 1
-  fi
-else
-  echo "Initializing op-geth"
-
-  mkdir -p datadir
-  echo "pwd" > datadir/password
-  echo $SEQUENCER_KEY > datadir/block-signer-key
-
-  geth account import --datadir=datadir --password=datadir/password datadir/block-signer-key
-
-  while [ ! -f "/op-node/jwt.txt" ]
-  do
-    echo "Config files not created. Checking after 5 seconds."
-    sleep 5
-  done
-
-  echo "Config files created by op-node, proceeding with the initialization..."
-
-  geth init --datadir=datadir /op-node/genesis.json
-  echo "Node Initialized"
-fi
-
-SEQUENCER_ADDRESS=$(jq -r '.Sequencer.address' /l2-accounts/keys.json | tr -d '"')
-echo "SEQUENCER_ADDRESS: ${SEQUENCER_ADDRESS}"
-
-cleanup() {
-    echo "Signal received, cleaning up..."
-    kill ${geth_pid}
-
-    wait
-    echo "Done"
-}
-trap 'cleanup' INT TERM
-
-# Run op-geth
-geth \
-  --datadir ./datadir \
-  --http \
-  --http.corsdomain="*" \
-  --http.vhosts="*" \
-  --http.addr=0.0.0.0 \
-  --http.api=web3,debug,eth,txpool,net,engine \
-  --ws \
-  --ws.addr=0.0.0.0 \
-  --ws.port=8546 \
-  --ws.origins="*" \
-  --ws.api=debug,eth,txpool,net,engine \
-  --syncmode=full \
-  --gcmode=archive \
-  --nodiscover \
-  --maxpeers=0 \
-  --networkid=42069 \
-  --authrpc.vhosts="*" \
-  --authrpc.addr=0.0.0.0 \
-  --authrpc.port=8551 \
-  --authrpc.jwtsecret=/op-node/jwt.txt \
-  --rollup.disabletxpoolgossip=true \
-  --password=./datadir/password \
-  --allow-insecure-unlock \
-  --mine \
-  --miner.etherbase=$SEQUENCER_ADDRESS \
-  --unlock=$SEQUENCER_ADDRESS \
-  &
-
-geth_pid=$!
-wait $geth_pid

app/data/config/fixturenet-optimism/run-op-node.sh

@@ -1,26 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Get Sequencer key from keys.json
-SEQUENCER_KEY=$(jq -r '.Sequencer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-# Run op-node
-op-node \
-  --l2=http://op-geth:8551 \
-  --l2.jwt-secret=/op-node-data/jwt.txt \
-  --sequencer.enabled \
-  --sequencer.l1-confs=3 \
-  --verifier.l1-confs=3 \
-  --rollup.config=/op-node-data/rollup.json \
-  --rpc.addr=0.0.0.0 \
-  --rpc.port=8547 \
-  --p2p.disable \
-  --rpc.enable-admin \
-  --p2p.sequencer.key=$SEQUENCER_KEY \
-  --l1=$CERC_L1_RPC \
-  --l1.rpckind=any

app/data/config/fixturenet-optimism/run-op-proposer.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_L1_RPC="${CERC_L1_RPC:-${DEFAULT_CERC_L1_RPC}}"
-
-# Read the L2OutputOracle contract address from the deployment
-L2OO_DEPLOYMENT=$(cat /contracts-bedrock/deployments/getting-started/L2OutputOracle.json)
-L2OO_ADDR=$(echo "$L2OO_DEPLOYMENT" | jq -r '.address')
-
-# Get Proposer key from keys.json
-PROPOSER_KEY=$(jq -r '.Proposer.privateKey' /l2-accounts/keys.json | tr -d '"')
-
-cleanup() {
-    echo "Signal received, cleaning up..."
-    kill ${proposer_pid}
-
-    wait
-    echo "Done"
-}
-trap 'cleanup' INT TERM
-
-# Run op-proposer
-op-proposer \
-  --poll-interval 12s \
-  --rpc.port 8560 \
-  --rollup-rpc http://op-node:8547 \
-  --l2oo-address $L2OO_ADDR \
-  --private-key $PROPOSER_KEY \
-  --l1-eth-rpc $CERC_L1_RPC \
-  &
-
-proposer_pid=$!
-wait $proposer_pid

app/data/config/watcher-azimuth/start-server.sh

@@ -1,27 +0,0 @@
-#!/bin/sh
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_IPLD_ETH_RPC="${CERC_IPLD_ETH_RPC:-${DEFAULT_CERC_IPLD_ETH_RPC}}"
-CERC_IPLD_ETH_GQL="${CERC_IPLD_ETH_GQL:-${DEFAULT_CERC_IPLD_ETH_GQL}}"
-
-echo "Using IPLD ETH RPC endpoint ${CERC_IPLD_ETH_RPC}"
-echo "Using IPLD GQL endpoint ${CERC_IPLD_ETH_GQL}"
-
-# Replace env variables in template TOML file
-# Read in the config template TOML file and modify it
-WATCHER_CONFIG_TEMPLATE=$(cat environments/watcher-config-template.toml)
-WATCHER_CONFIG=$(echo "$WATCHER_CONFIG_TEMPLATE" | \
-  sed -E "s|REPLACE_WITH_CERC_IPLD_ETH_RPC|${CERC_IPLD_ETH_RPC}|g; \
-          s|REPLACE_WITH_CERC_IPLD_ETH_GQL|${CERC_IPLD_ETH_GQL}| ")
-
-# Write the modified content to a new file
-echo "$WATCHER_CONFIG" > environments/watcher-config.toml
-
-# Merge SO watcher config with existing config file
-node merge-toml.js
-
-echo 'yarn server'
-yarn server

app/data/config/watcher-azimuth/watcher-config-template.toml

@@ -1,14 +0,0 @@
-[server]
-  host = "0.0.0.0"
-  maxSimultaneousRequests = -1
-
-[database]
-  host = "watcher-db"
-  port = 5432
-  username = "vdbm"
-  password = "password"
-
-[upstream]
-  [upstream.ethServer]
-    gqlApiEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_GQL"
-    rpcProviderEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_RPC"

app/data/config/watcher-azimuth/watcher-params.env

@@ -1,5 +0,0 @@
-# Defaults
-
-# ipld-eth-server endpoints
-DEFAULT_CERC_IPLD_ETH_RPC=
-DEFAULT_CERC_IPLD_ETH_GQL=

app/data/config/watcher-mobymask-v3/deploy-nitro-contracts.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_NA_ADDRESS="${CERC_NA_ADDRESS:-${DEFAULT_CERC_NA_ADDRESS}}"
-CERC_VPA_ADDRESS="${CERC_VPA_ADDRESS:-${DEFAULT_CERC_VPA_ADDRESS}}"
-CERC_CA_ADDRESS="${CERC_CA_ADDRESS:-${DEFAULT_CERC_CA_ADDRESS}}"
-
-NITRO_ADDRESSES_FILE_PATH="/nitro/nitro-addresses.json"
-
-# Check if CERC_NA_ADDRESS environment variable set to skip contract deployment
-if [ -n "$CERC_NA_ADDRESS" ]; then
-  echo "CERC_NA_ADDRESS is set to '$CERC_NA_ADDRESS'"
-  echo "CERC_VPA_ADDRESS is set to '$CERC_VPA_ADDRESS'"
-  echo "CERC_CA_ADDRESS is set to '$CERC_CA_ADDRESS'"
-  echo "Using the above addresses and skipping Nitro contracts deployment"
-
-  # Create the required JSON and write it to a file
-  nitro_addresses_json=$(jq -n \
-    --arg na "$CERC_NA_ADDRESS" \
-    --arg vpa "$CERC_VPA_ADDRESS" \
-    --arg ca "$CERC_CA_ADDRESS" \
-    '.nitroAdjudicatorAddress = $na | .virtualPaymentAppAddress = $vpa | .consensusAppAddress = $ca')
-  echo "$nitro_addresses_json" > "${NITRO_ADDRESSES_FILE_PATH}"
-
-  exit
-fi
-
-# Check and exit if a deployment already exists (on restarts)
-if [ -f ${NITRO_ADDRESSES_FILE_PATH} ]; then
-  echo "${NITRO_ADDRESSES_FILE_PATH} already exists, skipping Nitro contracts deployment"
-  exit
-fi
-
-echo "Using L2 RPC endpoint ${CERC_L2_GETH_RPC}"
-
-if [ -n "$CERC_L1_ACCOUNTS_CSV_URL" ] && \
-  l1_accounts_response=$(curl -L --write-out '%{http_code}' --silent --output /dev/null "$CERC_L1_ACCOUNTS_CSV_URL") && \
-  [ "$l1_accounts_response" -eq 200 ];
-then
-  echo "Fetching L1 account credentials using provided URL"
-  mkdir -p /geth-accounts
-  wget -O /geth-accounts/accounts.csv "$CERC_L1_ACCOUNTS_CSV_URL"
-
-  # Read the private key of an L1 account to deploy contract
-  CERC_PRIVATE_KEY_DEPLOYER=$(head -n 1 /geth-accounts/accounts.csv | cut -d ',' -f 3)
-else
-  echo "Couldn't fetch L1 account credentials, using CERC_PRIVATE_KEY_DEPLOYER from env"
-fi
-
-echo "RPC_URL=${CERC_L2_GETH_RPC}" > .env
-echo "NITRO_ADDRESSES_FILE_PATH=${NITRO_ADDRESSES_FILE_PATH}" >> .env
-echo "PRIVATE_KEY=${CERC_PRIVATE_KEY_DEPLOYER}" >> .env
-
-yarn ts-node --esm deploy-nitro-contracts.ts

app/data/config/watcher-mobymask-v3/deploy-nitro-contracts.ts

@@ -1,49 +0,0 @@
-import 'dotenv/config';
-import fs from 'fs';
-import { providers, Wallet } from 'ethers';
-import { deployContracts } from '@cerc-io/nitro-util';
-
-async function main () {
-  const rpcURL = process.env.RPC_URL;
-  const addressesFilePath = process.env.NITRO_ADDRESSES_FILE_PATH;
-  const deployerKey = process.env.PRIVATE_KEY;
-
-  if (!rpcURL) {
-    console.log('RPC_URL not set, skipping deployment');
-    return;
-  }
-
-  if (!addressesFilePath) {
-    console.log('NITRO_ADDRESSES_FILE_PATH not set, skipping deployment');
-    return;
-  }
-
-  if (!deployerKey) {
-    console.log('PRIVATE_KEY not set, skipping deployment');
-    return;
-  }
-
-  const provider = new providers.JsonRpcProvider(process.env.RPC_URL);
-  const signer = new Wallet(deployerKey, provider);
-
-  const [
-    nitroAdjudicatorAddress,
-    virtualPaymentAppAddress,
-    consensusAppAddress
-  ] = await deployContracts(signer as any);
-
-  const output = {
-    nitroAdjudicatorAddress,
-    virtualPaymentAppAddress,
-    consensusAppAddress
-  };
-
-  fs.writeFileSync(addressesFilePath, JSON.stringify(output, null, 2));
-  console.log('Nitro contracts deployed, addresses written to', addressesFilePath);
-  console.log('Result:', JSON.stringify(output, null, 2));
-}
-
-main()
-  .catch((err) => {
-    console.log(err);
-  });

app/data/config/watcher-mobymask-v3/mobymask-app-start.sh

@@ -1,64 +0,0 @@
-#!/bin/bash
-
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-
-CERC_CHAIN_ID="${CERC_CHAIN_ID:-${DEFAULT_CERC_CHAIN_ID}}"
-CERC_DEPLOYED_CONTRACT="${CERC_DEPLOYED_CONTRACT:-${DEFAULT_CERC_DEPLOYED_CONTRACT}}"
-CERC_RELAY_NODES="${CERC_RELAY_NODES:-${DEFAULT_CERC_RELAY_NODES}}"
-CERC_DENY_MULTIADDRS="${CERC_DENY_MULTIADDRS:-${DEFAULT_CERC_DENY_MULTIADDRS}}"
-CERC_PUBSUB="${CERC_PUBSUB:-${DEFAULT_CERC_PUBSUB}}"
-CERC_GOSSIPSUB_DIRECT_PEERS="${CERC_GOSSIPSUB_DIRECT_PEERS:-${DEFAULT_CERC_GOSSIPSUB_DIRECT_PEERS}}"
-
-echo "Using CERC_RELAY_NODES $CERC_RELAY_NODES"
-
-if [ -z "$CERC_DEPLOYED_CONTRACT" ]; then
-  echo "CERC_DEPLOYED_CONTRACT not set"
-  exit 1
-else
-  echo "Using CERC_DEPLOYED_CONTRACT ${CERC_DEPLOYED_CONTRACT} from env as the MobyMask contract address"
-fi
-
-# Checkout to the required release/branch
-cd /app
-git checkout $CERC_RELEASE
-
-# Check if CERC_NA_ADDRESS is set
-if [ -n "$CERC_NA_ADDRESS" ]; then
-  echo "CERC_NA_ADDRESS is set to '$CERC_NA_ADDRESS'"
-  echo "CERC_VPA_ADDRESS is set to '$CERC_VPA_ADDRESS'"
-  echo "CERC_CA_ADDRESS is set to '$CERC_CA_ADDRESS'"
-  echo "Using the above Nitro addresses"
-
-  # Create the required JSON and write it to a file
-  nitro_addresses_json=$(jq -n \
-    --arg na "$CERC_NA_ADDRESS" \
-    --arg vpa "$CERC_VPA_ADDRESS" \
-    --arg ca "$CERC_CA_ADDRESS" \
-    '.nitroAdjudicatorAddress = $na | .virtualPaymentAppAddress = $vpa | .consensusAppAddress = $ca')
-  echo "$nitro_addresses_json" > /app/src/utils/nitro-addresses.json
-else
-  echo "Nitro addresses not provided"
-  exit 1
-fi
-
-# Export config values in a json file
-jq --arg address "$CERC_DEPLOYED_CONTRACT" \
-  --argjson chainId "$CERC_CHAIN_ID" \
-  --argjson relayNodes "$CERC_RELAY_NODES" \
-  --argjson denyMultiaddrs "$CERC_DENY_MULTIADDRS" \
-  --arg pubsub "$CERC_PUBSUB" \
-  --argjson directPeers "$CERC_GOSSIPSUB_DIRECT_PEERS" \
-  '.address = $address | .chainId = $chainId | .relayNodes = $relayNodes | .peer.denyMultiaddrs = $denyMultiaddrs | .peer.pubsub = $pubsub | .peer.directPeers = $directPeers' \
-  /app/src/mobymask-app-config.json > /app/src/utils/config.json
-
-yarn install
-
-REACT_APP_WATCHER_URI="$CERC_APP_WATCHER_URL/graphql" \
-REACT_APP_PAY_TO_NITRO_ADDRESS="$CERC_PAYMENT_NITRO_ADDRESS" \
-REACT_APP_SNAP_ORIGIN="local:$CERC_SNAP_URL" \
-yarn build
-
-http-server -p 80 /app/build

app/data/container-build/cerc-fixturenet-eth-genesis/Dockerfile

@@ -1,27 +0,0 @@
-FROM skylenet/ethereum-genesis-generator@sha256:210353ce7c898686bc5092f16c61220a76d357f51eff9c451e9ad1b9ad03d4d3 AS ethgen
-
-FROM golang:1.20-alpine as builder
-
-RUN apk add --no-cache python3 py3-pip
-
-COPY genesis /opt/genesis
-
-# Install ethereum-genesis-generator tools
-COPY --from=ethgen /usr/local/bin/eth2-testnet-genesis /usr/local/bin/
-COPY --from=ethgen /usr/local/bin/eth2-val-tools /usr/local/bin/
-COPY --from=ethgen /apps /apps
-RUN cd /apps/el-gen && pip3 install -r requirements.txt
-# web3==5.24.0 used by el-gen is broken on python 3.11
-RUN pip3 install --upgrade "web3==6.5.0"
-
-# Build genesis config
-RUN apk add --no-cache make bash envsubst jq
-RUN cd /opt/genesis && make genesis-el
-
-# Snag the genesis block info.
-RUN go install github.com/cerc-io/eth-dump-genblock@latest
-RUN eth-dump-genblock /opt/genesis/build/el/geth.json > /opt/genesis/build/el/genesis_block.json
-
-FROM alpine:latest
-
-COPY --from=builder /opt/genesis /opt/genesis

app/data/container-build/cerc-fixturenet-eth-genesis/genesis/el/build_el.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-# See: https://github.com/skylenet/ethereum-genesis-generator/blob/master/entrypoint.sh
-
-rm -rf ../build/el
-mkdir -p ../build/el
-
-tmp_dir=$(mktemp -d -t ci-XXXXXXXXXX)
-envsubst < el-config.yaml > $tmp_dir/genesis-config.yaml
-
-ttd=`cat $tmp_dir/genesis-config.yaml | grep terminal_total_difficulty | awk '{ print $2 }'`
-homestead_block=`cat $tmp_dir/genesis-config.yaml | grep homestead_block | awk '{ print $2 }'`
-eip150_block=`cat $tmp_dir/genesis-config.yaml | grep eip150_block | awk '{ print $2 }'`
-eip155_block=`cat $tmp_dir/genesis-config.yaml | grep eip155_block | awk '{ print $2 }'`
-eip158_block=`cat $tmp_dir/genesis-config.yaml | grep eip158_block | awk '{ print $2 }'`
-byzantium_block=`cat $tmp_dir/genesis-config.yaml | grep byzantium_block | awk '{ print $2 }'`
-constantinople_block=`cat $tmp_dir/genesis-config.yaml | grep constantinople_block | awk '{ print $2 }'`
-petersburg_block=`cat $tmp_dir/genesis-config.yaml | grep petersburg_block | awk '{ print $2 }'`
-istanbul_block=`cat $tmp_dir/genesis-config.yaml | grep istanbul_block | awk '{ print $2 }'`
-berlin_block=`cat $tmp_dir/genesis-config.yaml | grep berlin_block | awk '{ print $2 }'`
-london_block=`cat $tmp_dir/genesis-config.yaml | grep london_block | awk '{ print $2 }'`
-merge_fork_block=`cat $tmp_dir/genesis-config.yaml | grep merge_fork_block | awk '{ print $2 }'`
-
-python3 /apps/el-gen/genesis_geth.py $tmp_dir/genesis-config.yaml | \
-  jq ".config.terminalTotalDifficulty=$ttd" | \
-  jq ".config.homesteadBlock=$homestead_block" | \
-  jq ".config.eip150Block=$eip150_block" | \
-  jq ".config.eip155Block=$eip155_block" | \
-  jq ".config.eip158Block=$eip158_block" | \
-  jq ".config.byzantiumBlock=$byzantium_block" | \
-  jq ".config.constantinopleBlock=$constantinople_block" | \
-  jq ".config.petersburgBlock=$petersburg_block" | \
-  jq ".config.istanbulBlock=$istanbul_block" | \
-  jq ".config.berlinBlock=$berlin_block" | \
-  jq ".config.londonBlock=$london_block" | \
-  jq ".config.mergeForkBlock=$merge_fork_block" | \
-  jq ".config.mergeNetsplitBlock=$merge_fork_block" \
-  > ../build/el/geth.json
-python3 ../accounts/mnemonic_to_csv.py $tmp_dir/genesis-config.yaml > ../build/el/accounts.csv

app/data/container-build/cerc-laconic-console-host/config.yml

@@ -1,6 +0,0 @@
-# Config for laconic-console running in a fixturenet with laconicd
-
-services:
-  wns:
-    server: 'LACONIC_HOSTED_ENDPOINT:9473/api'
-    webui: 'LACONIC_HOSTED_ENDPOINT:9473/console'

app/data/container-build/cerc-laconic-registry-cli/create-demo-records.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# Create some demo/test records in the registry
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-registry_command="laconic cns"
-record_1_filename=demo-record-1.yml
-cat <<EOF > ${record_1_filename}
-record:
-  type: WebsiteRegistrationRecord
-  url: 'https://cerc.io'
-  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
-  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
-  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
-  version: 1.0.23
-EOF
-# Check we have funds
-funds_response=$(${registry_command} account get --address $(cat my-address.txt))
-funds_balance=$(echo ${funds_response} | jq -r .[0].balance[0].quantity)
-echo "Balance is: ${funds_balance}"
-# Create a bond
-bond_create_result=$(${registry_command} bond create --type aphoton --quantity 1000000000)
-bond_id=$(echo ${bond_create_result} | jq -r .bondId)
-echo "Created bond with id: ${bond_id}"
-# Publish a demo record
-publish_response=$(${registry_command} record publish --filename ${record_1_filename} --bond-id ${bond_id})
-published_record_id=$(echo ${publish_response} | jq -r .id)
-echo "Published ${record_1_filename} with id: ${published_record_id}"

app/data/container-build/cerc-lighthouse/Dockerfile

@@ -1,9 +0,0 @@
-ARG TAG_SUFFIX="-modern"
-FROM sigp/lighthouse:v4.3.0${TAG_SUFFIX}
-
-RUN apt-get update; apt-get install bash netcat curl less jq wget -y;
-
-WORKDIR /root/
-ADD start-lighthouse.sh .
-
-ENTRYPOINT [ "./start-lighthouse.sh" ]

app/data/container-build/cerc-plugeth-statediff/build.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/plugeth-statediff
-source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
-# This container build currently requires access to private dependencies in gitea
-# so we check that the necessary access token has been supplied here, then pass it o the build
-if [[ -z "${CERC_GO_AUTH_TOKEN}" ]]; then
-    echo "ERROR: CERC_GO_AUTH_TOKEN is not set" >&2
-    exit 1
-fi
-docker build -t cerc/plugeth-statediff:local ${build_command_args} --build-arg GIT_VDBTO_TOKEN=${CERC_GO_AUTH_TOKEN} ${CERC_REPO_BASE_DIR}/plugeth-statediff

app/data/container-build/cerc-plugeth/build.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-# Build cerc/plugeth
-source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
-# This container build currently requires access to private dependencies in gitea
-# so we check that the necessary access token has been supplied here, then pass it o the build
-if [[ -z "${CERC_GO_AUTH_TOKEN}" ]]; then
-    echo "ERROR: CERC_GO_AUTH_TOKEN is not set" >&2
-    exit 1
-fi
-docker build -t cerc/plugeth:local ${build_command_args} --build-arg GIT_VDBTO_TOKEN=${CERC_GO_AUTH_TOKEN} ${CERC_REPO_BASE_DIR}/plugeth

app/data/container-build/cerc-test-container/run.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-set -e
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-  set -x
-fi
-# Test if the container's filesystem is old (run previously) or new
-EXISTSFILENAME=/data/exists
-echo "Test container starting"
-if [[ -f "$EXISTSFILENAME" ]];
-then
-    TIMESTAMP=`cat $EXISTSFILENAME`
-    echo "Filesystem is old, created: $TIMESTAMP" 
-else
-    echo "Filesystem is fresh"
-    echo `date` > $EXISTSFILENAME
-fi
-
-# Run nginx which will block here forever
-/usr/sbin/nginx -g "daemon off;"

app/data/container-build/cerc-watcher-azimuth/Dockerfile

@@ -1,13 +0,0 @@
-FROM node:18.16.0-alpine3.16
-
-RUN apk --update --no-cache add git python3 alpine-sdk
-
-WORKDIR /app
-
-COPY . .
-
-RUN echo "Building azimuth-watcher-ts" && \
-    yarn && yarn build
-
-RUN echo "Install toml-js to update watcher config files" && \
-    yarn add --dev --ignore-workspace-root-check toml-js

app/data/container-build/cerc-watcher-erc20/Dockerfile

@@ -1,13 +0,0 @@
-FROM node:16.17.1-alpine3.16
-
-RUN apk --update --no-cache add git python3 alpine-sdk
-
-WORKDIR /app
-
-COPY . .
-
-RUN echo "Building watcher-ts" && \
-    git checkout v0.2.19 && \
-    yarn && yarn build
-
-WORKDIR /app/packages/erc20-watcher

app/data/container-build/cerc-webapp-base/config.yml

@@ -1 +0,0 @@
-# Put config here.

app/data/container-build/cerc-webapp-base/start-serving-app.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-if [ -n "$CERC_SCRIPT_DEBUG" ]; then
-    set -x
-fi
-
-CERC_WEBAPP_FILES_DIR="${CERC_WEBAPP_FILES_DIR:-/data}"
-
-/scripts/apply-webapp-config.sh /config/config.yml ${CERC_WEBAPP_FILES_DIR}
-http-server -p 80 ${CERC_WEBAPP_FILES_DIR}

app/data/stacks/azimuth/README.md

@@ -1,72 +0,0 @@
-# Azimuth Watcher
-
-Instructions to setup and deploy Azimuth Watcher stack
-
-## Setup
-
-Prerequisite: `ipld-eth-server` RPC and GQL endpoints
-
-Clone required repositories:
-
-```bash
-laconic-so --stack azimuth setup-repositories
-```
-
-NOTE: If the repository already exists and checked out to a different version, `setup-repositories` command will throw an error.
-For getting around this, the `azimuth-watcher-ts` repository can be removed and then run the command.
-
-Checkout to the required versions and branches in repos
-
-```bash
-# azimuth-watcher-ts
-cd ~/cerc/azimuth-watcher-ts
-git checkout v0.1.0
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack azimuth build-containers
-```
-
-This should create the required docker images in the local image registry.
-
-### Configuration
-
-* Create and update an env file to be used in the next step:
-
-  ```bash
-  # External ipld-eth-server endpoints
-  CERC_IPLD_ETH_RPC=
-  CERC_IPLD_ETH_GQL=
-  ```
-
-* NOTE: If `ipld-eth-server` is running on the host machine, use `host.docker.internal` as the hostname to access host ports
-
-### Deploy the stack
-
-* Deploy the containers:
-
-  ```bash
-  laconic-so --stack azimuth deploy-system --env-file <PATH_TO_ENV_FILE> up
-  ```
-
-* List and check the health status of all the containers using `docker ps` and wait for them to be `healthy`
-
-## Clean up
-
-Stop all the services running in background:
-
-```bash
-laconic-so --stack azimuth deploy-system down
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*watcher_db_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*watcher_db_data")
-```

app/data/stacks/chain-chunker/stack.yml

@@ -1,13 +0,0 @@
-version: "1.0"
-name: chain-chunker
-description: "Stack to build containers for chain-chunker"
-repos:
-  - github.com/cerc-io/ipld-eth-state-snapshot@v5
-  - github.com/cerc-io/eth-statediff-service@v5
-  - github.com/cerc-io/ipld-eth-db@v5
-  - github.com/cerc-io/ipld-eth-server@v5
-containers:
-  - cerc/ipld-eth-state-snapshot
-  - cerc/eth-statediff-service
-  - cerc/ipld-eth-db
-  - cerc/ipld-eth-server

app/data/stacks/fixturenet-optimism/README.md

@@ -1,123 +0,0 @@
-# fixturenet-optimism
-
-Instructions to setup and deploy an end-to-end L1+L2 stack with [fixturenet-eth](../fixturenet-eth/) (L1) and [Optimism](https://stack.optimism.io) (L2)
-
-We support running just the L2 part of stack, given an external L1 endpoint. Follow the [L2 only doc](./l2-only.md) for the same.
-
-## Setup
-
-Clone required repositories:
-
-```bash
-laconic-so --stack fixturenet-optimism setup-repositories
-
-# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack fixturenet-optimism build-containers
-
-# If redeploying with changes in the stack containers
-laconic-so --stack fixturenet-optimism build-containers --force-rebuild
-
-# If errors are thrown during build, old images used by this stack would have to be deleted
-```
-
-Note: this will take >10 mins depending on the specs of your machine, and **requires** 16GB of memory or greater.
-
-This should create the required docker images in the local image registry:
-* `cerc/go-ethereum`
-* `cerc/lighthouse`
-* `cerc/fixturenet-eth-geth`
-* `cerc/fixturenet-eth-lighthouse`
-* `cerc/foundry`
-* `cerc/optimism-contracts`
-* `cerc/optimism-l2geth`
-* `cerc/optimism-op-node`
-* `cerc/optimism-op-batcher`
-* `cerc/optimism-op-proposer`
-
-## Deploy
-
-Deploy the stack:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy up
-```
-
-The `fixturenet-optimism-contracts` service takes a while to complete running as it:
-1. waits for the 'Merge' to happen on L1
-2. waits for a finalized block to exist on L1 (so that it can be taken as a starting block for roll ups)
-3. deploys the L1 contracts
-It may restart a few times after running into errors.
-
-To list and monitor the running containers:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy ps
-
-# With status
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Clean up
-
-Stop all services running in the background:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy down 30
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data")
-```
-
-## Troubleshooting
-
-* If `op-geth` service aborts or is restarted, the following error might occur in the `op-node` service:
-
-  ```bash
-  WARN [02-16|21:22:02.868] Derivation process temporary error       attempts=14 err="stage 0 failed resetting: temp: failed to find the L2 Heads to start from: failed to fetch L2 block by hash 0x0000000000000000000000000000000000000000000000000000000000000000: failed to determine block-hash of hash 0x0000000000000000000000000000000000000000000000000000000000000000, could not get payload: not found"
-  ```
-
-* This means that the data directory that `op-geth` is using is corrupted and needs to be reinitialized; the containers `op-geth`, `op-node` and `op-batcher` need to be started afresh:
-
-  WARNING: This will reset the L2 chain; consequently, all the data on it will be lost
-
-  * Stop and remove the concerned containers:
-
-    ```bash
-    # List the containers
-    docker ps -f "name=op-geth|op-node|op-batcher"
-
-    # Force stop and remove the listed containers
-    docker rm -f $(docker ps -qf "name=op-geth|op-node|op-batcher")
-    ```
-
-  * Remove the concerned volume:
-
-    ```bash
-    # List the volume
-    docker volume ls -q --filter name=l2_geth_data
-
-    # Remove the listed volume
-    docker volume rm $(docker volume ls -q --filter name=l2_geth_data)
-    ```
-
-  * Re-run the deployment command used in [Deploy](#deploy) to restart the stopped containers
-
-## Known Issues
-
-* Resource requirements (memory + time) for building the `cerc/foundry` image are on the higher side
-  * `cerc/optimism-contracts` image is currently based on `cerc/foundry` (Optimism requires foundry installation)

app/data/stacks/fixturenet-optimism/l2-only.md

@@ -1,100 +0,0 @@
-# fixturenet-optimism
-
-Instructions to setup and deploy L2 fixturenet using [Optimism](https://stack.optimism.io)
-
-## Setup
-
-Prerequisite: An L1 Ethereum RPC endpoint
-
-Clone required repositories:
-
-```bash
-laconic-so --stack fixturenet-optimism setup-repositories --exclude github.com/cerc-io/go-ethereum
-
-# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
-```
-
-Build the container images:
-
-```bash
-laconic-so --stack fixturenet-optimism build-containers --include cerc/foundry,cerc/optimism-contracts,cerc/optimism-op-node,cerc/optimism-l2geth,cerc/optimism-op-batcher,cerc/optimism-op-proposer
-```
-
-This should create the required docker images in the local image registry:
-* `cerc/foundry`
-* `cerc/optimism-contracts`
-* `cerc/optimism-l2geth`
-* `cerc/optimism-op-node`
-* `cerc/optimism-op-batcher`
-* `cerc/optimism-op-proposer`
-
-## Deploy
-
-Create and update an env file to be used in the next step ([defaults](../../config/fixturenet-optimism/l1-params.env)):
-
-  ```bash
-  # External L1 endpoint
-  CERC_L1_CHAIN_ID=
-  CERC_L1_RPC=
-  CERC_L1_HOST=
-  CERC_L1_PORT=
-
-  # URL to get CSV with credentials for accounts on L1
-  # that are used to send balance to Optimism Proxy contract
-  # (enables them to do transactions on L2)
-  CERC_L1_ACCOUNTS_CSV_URL=
-
-  # OR
-  # Specify the required account credentials
-  CERC_L1_ADDRESS=
-  CERC_L1_PRIV_KEY=
-  CERC_L1_ADDRESS_2=
-  CERC_L1_PRIV_KEY_2=
-  ```
-
-* NOTE: If L1 is running on the host machine, use `host.docker.internal` as the hostname to access the host port
-
-Deploy the stack:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism --env-file <PATH_TO_ENV_FILE> up
-```
-
-The `fixturenet-optimism-contracts` service may take a while (`~15 mins`) to complete running as it:
-1. waits for the 'Merge' to happen on L1
-2. waits for a finalized block to exist on L1 (so that it can be taken as a starting block for roll ups)
-3. deploys the L1 contracts
-
-To list down and monitor the running containers:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism ps
-
-# With status
-docker ps
-
-# Check logs for a container
-docker logs -f <CONTAINER_ID>
-```
-
-## Clean up
-
-Stop all services running in the background:
-
-```bash
-laconic-so --stack fixturenet-optimism deploy --include fixturenet-optimism down 30
-```
-
-Clear volumes created by this stack:
-
-```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*l1_deployment|.*l2_accounts|.*l2_config|.*l2_geth_data")
-```
-
-## Troubleshooting
-
-See [Troubleshooting](./README.md#troubleshooting)

app/data/stacks/mainnet-laconic/stack.yml

@@ -1,29 +0,0 @@
-version: "1.0"
-name: mainnet-laconic
-description: "Mainnet laconic node"
-repos:
-  - cerc-io/laconicd
-  - lirewine/debug
-  - lirewine/crypto
-  - lirewine/gem
-  - lirewine/sdk
-  - cerc-io/laconic-sdk
-  - cerc-io/laconic-registry-cli
-  - cerc-io/laconic-console
-npms:
-  - laconic-sdk
-  - laconic-registry-cli
-  - debug
-  - crypto
-  - sdk
-  - gem
-  - laconic-console
-containers:
-  - cerc/laconicd
-  - cerc/laconic-registry-cli
-  - cerc/webapp-base
-  - cerc/laconic-console-host
-pods:
-  - mainnet-laconicd
-  - fixturenet-laconic-console
-

app/data/stacks/package-registry/README.md

@@ -1,5 +0,0 @@
-# Package Registry Stack
-
-The Package Registry Stack supports a build environment that requires a package registry (initially for NPM packages only).
-
-Setup instructions can be found [here](../build-support/README.md).

app/deployment_create.py

@@ -1,315 +0,0 @@
-# Copyright © 2022, 2023 Vulcanize
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# 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/>.
-
-import click
-from importlib import util
-import os
-from pathlib import Path
-import random
-from shutil import copyfile, copytree
-import sys
-from app.util import get_stack_file_path, get_parsed_deployment_spec, get_parsed_stack_config, global_options, get_yaml
-from app.util import get_compose_file_dir
-from app.deploy_types import DeploymentContext, LaconicStackSetupCommand
-
-
-def _make_default_deployment_dir():
-    return "deployment-001"
-
-
-def _get_ports(stack):
-    ports = {}
-    parsed_stack = get_parsed_stack_config(stack)
-    pods = parsed_stack["pods"]
-    yaml = get_yaml()
-    for pod in pods:
-        pod_file_path = os.path.join(get_compose_file_dir(), f"docker-compose-{pod}.yml")
-        parsed_pod_file = yaml.load(open(pod_file_path, "r"))
-        if "services" in parsed_pod_file:
-            for svc_name, svc in parsed_pod_file["services"].items():
-                if "ports" in svc:
-                    # Ports can appear as strings or numbers.  We normalize them as strings.
-                    ports[svc_name] = [str(x) for x in svc["ports"]]
-    return ports
-
-
-def _get_named_volumes(stack):
-    # Parse the compose files looking for named volumes
-    named_volumes = []
-    parsed_stack = get_parsed_stack_config(stack)
-    pods = parsed_stack["pods"]
-    yaml = get_yaml()
-    for pod in pods:
-        pod_file_path = os.path.join(get_compose_file_dir(), f"docker-compose-{pod}.yml")
-        parsed_pod_file = yaml.load(open(pod_file_path, "r"))
-        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
-
-
-# If we're mounting a volume from a relatie path, then we
-# assume the directory doesn't exist yet and create it
-# so the deployment will start
-# Also warn if the path is absolute and doesn't exist
-def _create_bind_dir_if_relative(volume, path_string, compose_dir):
-    path = Path(path_string)
-    if not path.is_absolute():
-        absolute_path = Path(compose_dir).parent.joinpath(path)
-        absolute_path.mkdir(parents=True, exist_ok=True)
-    else:
-        if not path.exists():
-            print(f"WARNING: mount path for volume {volume} does not exist: {path_string}")
-
-
-# See: https://stackoverflow.com/questions/45699189/editing-docker-compose-yml-with-pyyaml
-def _fixup_pod_file(pod, spec, compose_dir):
-    # Fix up volumes
-    if "volumes" in spec:
-        spec_volumes = spec["volumes"]
-        if "volumes" in pod:
-            pod_volumes = pod["volumes"]
-            for volume in pod_volumes.keys():
-                if volume in spec_volumes:
-                    volume_spec = spec_volumes[volume]
-                    volume_spec_fixedup = volume_spec if Path(volume_spec).is_absolute() else f".{volume_spec}"
-                    _create_bind_dir_if_relative(volume, volume_spec, compose_dir)
-                    new_volume_spec = {"driver": "local",
-                                       "driver_opts": {
-                                          "type": "none",
-                                          "device": volume_spec_fixedup,
-                                          "o": "bind"
-                                       }
-                                       }
-                    pod["volumes"][volume] = new_volume_spec
-    # Fix up ports
-    if "ports" in spec:
-        spec_ports = spec["ports"]
-        for container_name, container_ports in spec_ports.items():
-            if container_name in pod["services"]:
-                pod["services"][container_name]["ports"] = container_ports
-
-
-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 = get_stack_file_path(deploy_command_context.stack).parent.joinpath("deploy", "commands.py")
-    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)
-        return imported_stack.init(deploy_command_context)
-    else:
-        return None
-
-
-# TODO: fold this with function above
-def call_stack_deploy_setup(deploy_command_context, parameters: LaconicStackSetupCommand, extra_args):
-    # Link with the python file in the stack
-    # Call a function in it
-    # If no function found, return None
-    python_file_path = get_stack_file_path(deploy_command_context.stack).parent.joinpath("deploy", "commands.py")
-    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)
-        return imported_stack.setup(deploy_command_context, parameters, extra_args)
-    else:
-        return None
-
-
-# TODO: fold this with function above
-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 = get_stack_file_path(deployment_context.command_context.stack).parent.joinpath("deploy", "commands.py")
-    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)
-        return imported_stack.create(deployment_context, extra_args)
-    else:
-        return None
-
-
-# Inspect the pod yaml to find config files referenced in subdirectories
-# other than the one associated with the pod
-def _find_extra_config_dirs(parsed_pod_file, pod):
-    config_dirs = set()
-    services = parsed_pod_file["services"]
-    for service in services:
-        service_info = services[service]
-        if "volumes" in service_info:
-            for volume in service_info["volumes"]:
-                if ":" in volume:
-                    host_path = volume.split(":")[0]
-                    if host_path.startswith("../config"):
-                        config_dir = host_path.split("/")[2]
-                        if config_dir != pod:
-                            config_dirs.add(config_dir)
-    return config_dirs
-
-
-def _get_mapped_ports(stack: str, map_recipe: str):
-    port_map_recipes = ["any-variable-random", "localhost-same", "any-same", "localhost-fixed-random", "any-fixed-random"]
-    ports = _get_ports(stack)
-    if ports:
-        # Implement any requested mapping recipe
-        if map_recipe:
-            if map_recipe in port_map_recipes:
-                for service in ports.keys():
-                    ports_array = ports[service]
-                    for x in range(0, len(ports_array)):
-                        orig_port = ports_array[x]
-                        # Strip /udp suffix if present
-                        bare_orig_port = orig_port.replace("/udp", "")
-                        random_port = random.randint(20000, 50000)  # Beware: we're relying on luck to not collide
-                        if map_recipe == "any-variable-random":
-                            # This is the default so take no action
-                            pass
-                        elif map_recipe == "localhost-same":
-                            # Replace instances of "- XX" with "- 127.0.0.1:XX"
-                            ports_array[x] = f"127.0.0.1:{bare_orig_port}:{orig_port}"
-                        elif map_recipe == "any-same":
-                            # Replace instances of "- XX" with "- 0.0.0.0:XX"
-                            ports_array[x] = f"0.0.0.0:{bare_orig_port}:{orig_port}"
-                        elif map_recipe == "localhost-fixed-random":
-                            # Replace instances of "- XX" with "- 127.0.0.1:<rnd>:XX"
-                            ports_array[x] = f"127.0.0.1:{random_port}:{orig_port}"
-                        elif map_recipe == "any-fixed-random":
-                            # Replace instances of "- XX" with "- 0.0.0.0:<rnd>:XX"
-                            ports_array[x] = f"0.0.0.0:{random_port}:{orig_port}"
-                        else:
-                            print("Error: bad map_recipe")
-            else:
-                print(f"Error: --map-ports-to-host must specify one of: {port_map_recipes}")
-                sys.exit(1)
-    return ports
-
-
-@click.command()
-@click.option("--output", required=True, help="Write yaml spec file here")
-@click.option("--map-ports-to-host", required=False,
-              help="Map ports to the host as one of: any-variable-random (default), "
-              "localhost-same, any-same, localhost-fixed-random, any-fixed-random")
-@click.pass_context
-def init(ctx, output, map_ports_to_host):
-    yaml = get_yaml()
-    stack = global_options(ctx).stack
-    verbose = global_options(ctx).verbose
-    default_spec_file_content = call_stack_deploy_init(ctx.obj)
-    spec_file_content = {"stack": stack}
-    if default_spec_file_content:
-        spec_file_content.update(default_spec_file_content)
-    if verbose:
-        print(f"Creating spec file for stack: {stack}")
-
-    ports = _get_mapped_ports(stack, map_ports_to_host)
-    spec_file_content["ports"] = ports
-
-    named_volumes = _get_named_volumes(stack)
-    if named_volumes:
-        volume_descriptors = {}
-        for named_volume in named_volumes:
-            volume_descriptors[named_volume] = f"./data/{named_volume}"
-        spec_file_content["volumes"] = volume_descriptors
-
-    with open(output, "w") as output_file:
-        yaml.dump(spec_file_content, output_file)
-
-
-@click.command()
-@click.option("--spec-file", required=True, help="Spec file to use to create this deployment")
-@click.option("--deployment-dir", help="Create deployment files in this directory")
-# TODO: Hack
-@click.option("--network-dir", help="Network configuration supplied in this directory")
-@click.option("--initial-peers", help="Initial set of persistent peers")
-@click.pass_context
-def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
-    # This function fails with a useful error message if the file doens't exist
-    parsed_spec = get_parsed_deployment_spec(spec_file)
-    stack_name = parsed_spec['stack']
-    stack_file = get_stack_file_path(stack_name)
-    parsed_stack = get_parsed_stack_config(stack_name)
-    if global_options(ctx).debug:
-        print(f"parsed spec: {parsed_spec}")
-    if deployment_dir is None:
-        deployment_dir = _make_default_deployment_dir()
-    if os.path.exists(deployment_dir):
-        print(f"Error: {deployment_dir} already exists")
-        sys.exit(1)
-    os.mkdir(deployment_dir)
-    # Copy spec file and the stack file into the deployment dir
-    copyfile(spec_file, os.path.join(deployment_dir, os.path.basename(spec_file)))
-    copyfile(stack_file, os.path.join(deployment_dir, os.path.basename(stack_file)))
-    # Copy the pod files into the deployment dir, fixing up content
-    pods = parsed_stack['pods']
-    destination_compose_dir = os.path.join(deployment_dir, "compose")
-    os.mkdir(destination_compose_dir)
-    data_dir = Path(__file__).absolute().parent.joinpath("data")
-    yaml = get_yaml()
-    for pod in pods:
-        pod_file_path = os.path.join(get_compose_file_dir(), f"docker-compose-{pod}.yml")
-        parsed_pod_file = yaml.load(open(pod_file_path, "r"))
-        extra_config_dirs = _find_extra_config_dirs(parsed_pod_file, pod)
-        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:
-            yaml.dump(parsed_pod_file, output_file)
-        # Copy the config files for the pod, if any
-        config_dirs = {pod}
-        config_dirs = config_dirs.union(extra_config_dirs)
-        for config_dir in config_dirs:
-            source_config_dir = data_dir.joinpath("config", config_dir)
-            if os.path.exists(source_config_dir):
-                destination_config_dir = os.path.join(deployment_dir, "config", config_dir)
-                # If the same config dir appears in multiple pods, it may already have been copied
-                if not os.path.exists(destination_config_dir):
-                    copytree(source_config_dir, destination_config_dir)
-    # Delegate to the stack's Python code
-    # The deploy create command doesn't require a --stack argument so we need to insert the
-    # stack member here.
-    deployment_command_context = ctx.obj
-    deployment_command_context.stack = stack_name
-    deployment_context = DeploymentContext(Path(deployment_dir), deployment_command_context)
-    call_stack_deploy_create(deployment_context, [network_dir, initial_peers])
-
-
-# TODO: this code should be in the stack .py files but
-# we haven't yet figured out how to integrate click across
-# the plugin boundary
-@click.command()
-@click.option("--node-moniker", help="Moniker for this node")
-@click.option("--chain-id", help="The new chain id")
-@click.option("--key-name", help="Name for new node key")
-@click.option("--gentx-files", help="List of comma-delimited gentx filenames from other nodes")
-@click.option("--genesis-file", help="Genesis file for the network")
-@click.option("--initialize-network", is_flag=True, default=False, help="Initialize phase")
-@click.option("--join-network", is_flag=True, default=False, help="Join phase")
-@click.option("--create-network", is_flag=True, default=False, help="Create phase")
-@click.option("--network-dir", help="Directory for network files")
-@click.argument('extra_args', nargs=-1)
-@click.pass_context
-def setup(ctx, node_moniker, chain_id, key_name, gentx_files, genesis_file, initialize_network, join_network, create_network,
-          network_dir, extra_args):
-    parmeters = LaconicStackSetupCommand(chain_id, node_moniker, key_name, initialize_network, join_network, create_network,
-                                         gentx_files, genesis_file, network_dir)
-    call_stack_deploy_setup(ctx.obj, parmeters, extra_args)

app/util.py

@@ -1,96 +0,0 @@
-# Copyright © 2022, 2023 Vulcanize
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# 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/>.
-
-import os.path
-import sys
-import ruamel.yaml
-from pathlib import Path
-
-
-def include_exclude_check(s, include, exclude):
-    if include is None and exclude is None:
-        return True
-    if include is not None:
-        include_list = include.split(",")
-        return s in include_list
-    if exclude is not None:
-        exclude_list = exclude.split(",")
-        return s not in exclude_list
-
-
-def get_stack_file_path(stack):
-    # In order to be compatible with Python 3.8 we need to use this hack to get the path:
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    stack_file_path = Path(__file__).absolute().parent.joinpath("data", "stacks", stack, "stack.yml")
-    return stack_file_path
-
-
-# Caller can pass either the name of a stack, or a path to a stack file
-def get_parsed_stack_config(stack):
-    stack_file_path = stack if isinstance(stack, os.PathLike) else get_stack_file_path(stack)
-    try:
-        with stack_file_path:
-            stack_config = get_yaml().load(open(stack_file_path, "r"))
-            return stack_config
-    except FileNotFoundError as error:
-        # We try here to generate a useful diagnostic error
-        # First check if the stack directory is present
-        stack_directory = stack_file_path.parent
-        if os.path.exists(stack_directory):
-            print(f"Error: stack.yml file is missing from stack: {stack}")
-        else:
-            print(f"Error: stack: {stack} does not exist")
-        print(f"Exiting, error: {error}")
-        sys.exit(1)
-
-
-def get_compose_file_dir():
-    # TODO: refactor to use common code with deploy command
-    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
-    data_dir = Path(__file__).absolute().parent.joinpath("data")
-    source_compose_dir = data_dir.joinpath("compose")
-    return source_compose_dir
-
-
-def get_parsed_deployment_spec(spec_file):
-    spec_file_path = Path(spec_file)
-    try:
-        with spec_file_path:
-            deploy_spec = get_yaml().load(open(spec_file_path, "r"))
-            return deploy_spec
-    except FileNotFoundError as error:
-        # We try here to generate a useful diagnostic error
-        print(f"Error: spec file: {spec_file_path} does not exist")
-        print(f"Exiting, error: {error}")
-        sys.exit(1)
-
-
-def get_yaml():
-    # See: https://stackoverflow.com/a/45701840/1701505
-    yaml = ruamel.yaml.YAML()
-    yaml.preserve_quotes = True
-    yaml.indent(sequence=3, offset=1)
-    return yaml
-
-
-# TODO: this is fragile wrt to the subcommand depth
-# See also: https://github.com/pallets/click/issues/108
-def global_options(ctx):
-    return ctx.parent.parent.obj
-
-
-# TODO: hack
-def global_options2(ctx):
-    return ctx.parent.obj

cli.py

@@ -1,52 +0,0 @@
-# Copyright © 2022, 2023 Vulcanize
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# 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/>.
-
-import click
-
-from app.command_types import CommandOptions
-from app import setup_repositories
-from app import build_containers
-from app import build_npms
-from app import deploy
-from app import version
-from app import deployment
-from app import update
-
-CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
-
-
-@click.group(context_settings=CONTEXT_SETTINGS)
-@click.option('--stack', help="specify a stack to build/deploy")
-@click.option('--quiet', is_flag=True, default=False)
-@click.option('--verbose', is_flag=True, default=False)
-@click.option('--dry-run', is_flag=True, default=False)
-@click.option('--local-stack', is_flag=True, default=False)
-@click.option('--debug', is_flag=True, default=False)
-@click.option('--continue-on-error', is_flag=True, default=False)
-# See: https://click.palletsprojects.com/en/8.1.x/complex/#building-a-git-clone
-@click.pass_context
-def cli(ctx, stack, quiet, verbose, dry_run, local_stack, debug, continue_on_error):
-    """Laconic Stack Orchestrator"""
-    ctx.obj = CommandOptions(stack, quiet, verbose, dry_run, local_stack, debug, continue_on_error)
-
-
-cli.add_command(setup_repositories.command, "setup-repositories")
-cli.add_command(build_containers.command, "build-containers")
-cli.add_command(build_npms.command, "build-npms")
-cli.add_command(deploy.command, "deploy")  # deploy is an alias for deploy-system
-cli.add_command(deploy.command, "deploy-system")
-cli.add_command(deployment.command, "deployment")
-cli.add_command(version.command, "version")
-cli.add_command(update.command, "update")

docs/CONTRIBUTING.md

@@ -26,7 +26,7 @@ In addition to the pre-requisites listed in the [README](/README.md), the follow
 
 1. Clone this repository:
    ```
-   $ git clone https://github.com/cerc-io/stack-orchestrator.git
+   $ git clone https://git.vdb.to/cerc-io/stack-orchestrator.git
    ```
 
 2. Enter the project directory:

docs/README.md

@@ -0,0 +1,8 @@
+# Stack Orchestrator
+
+Here you will find information about the design of stack orchestrator, contributing to it, and deploying services/applications that combine two or more "stacks".
+
+Most "stacks" contain their own README which has plenty of information on deploying, but stacks can be combined in a variety of ways which are document here, for example:
+
+- [Gitea with Laconicd Fixturenet](./gitea-with-laconicd-fixturenet.md)
+- [Laconicd Registry with Console](./laconicd-with-console.md)

docs/adding-a-new-stack.md

@@ -0,0 +1,71 @@
+# Adding a new stack
+
+See [this PR](https://git.vdb.to/cerc-io/stack-orchestrator/pull/434) for an example of how to currently add a minimal stack to stack orchestrator. The [reth stack](https://git.vdb.to/cerc-io/stack-orchestrator/pull/435) is another good example.
+
+For external developers, we recommend forking this repo and adding your stack directly to your fork. This initially requires running in "developer mode" as described [here](/docs/CONTRIBUTING.md). Check out the [Namada stack](https://github.com/vknowable/stack-orchestrator/blob/main/app/data/stacks/public-namada/digitalocean_quickstart.md) from Knowable to see how that is done.
+
+Core to the feature completeness of stack orchestrator is to [decouple the tool functionality from payload](https://git.vdb.to/cerc-io/stack-orchestrator/issues/315) which will no longer require forking to add a stack.
+
+## Example
+
+- in `stack_orchestrator/data/stacks/my-new-stack/stack.yml` add:
+
+```yaml
+version: "0.1"
+name: my-new-stack
+repos:
+  - github.com/my-org/my-new-stack
+containers:
+  - cerc/my-new-stack
+pods:
+  - my-new-stack
+```
+
+- in `stack_orchestrator/data/container-build/cerc-my-new-stack/build.sh` add:
+
+```yaml
+#!/usr/bin/env bash
+# Build the my-new-stack image
+source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
+docker build -t cerc/my-new-stack:local -f ${CERC_REPO_BASE_DIR}/my-new-stack/Dockerfile ${build_command_args} ${CERC_REPO_BASE_DIR}/my-new-stack
+```
+
+- in `stack_orchestrator/data/compose/docker-compose-my-new-stack.yml` add:
+
+```yaml
+version: "3.2"
+
+services:
+  my-new-stack:
+    image: cerc/my-new-stack:local
+    restart: always
+    ports:
+      - "0.0.0.0:3000:3000"
+```
+
+- in `stack_orchestrator/data/repository-list.txt` add:
+
+```bash
+github.com/my-org/my-new-stack
+```
+whereby that repository contains your source code and a `Dockerfile`, and matches the `repos:` field in the `stack.yml`.
+
+- in `stack_orchestrator/data/container-image-list.txt` add:
+
+```bash
+cerc/my-new-stack
+```
+
+- in `stack_orchestrator/data/pod-list.txt` add:
+
+```bash
+my-new-stack
+```
+
+Now, the following commands will fetch, build, and deploy you app:
+
+```bash
+laconic-so --stack my-new-stack setup-repositories
+laconic-so --stack my-new-stack build-containers
+laconic-so --stack my-new-stack deploy-system up
+```

docs/cli.md

@@ -6,7 +6,7 @@ Sub-commands and flags
 
 Clone a single repository:
 ```
-$ laconic-so setup-repositories --include cerc-io/go-ethereum
+$ laconic-so setup-repositories --include github.com/cerc-io/go-ethereum
 ```
 Clone the repositories for a stack:
 ```
@@ -51,7 +51,7 @@ $ laconic-so build-npms --include <package-name>
 ```
 e.g.
 ```
-$ laconic-so build-npms --include laconic-sdk
+$ laconic-so build-npms --include registry-sdk
 ```
 Build the packages for a stack:
 ```

docs/fetching-containers.md

@@ -0,0 +1,9 @@
+# Fetching pre-built container images
+When Stack Orchestrator deploys a stack containing a suite of one or more containers it expects images for those containers to be on the local machine with a tag of the form `<image-name>:local` Images for these containers can be built from source (and optionally base container images from public registries) with the `build-containers` subcommand. 
+
+However, the task of building a large number of containers from source may consume considerable time and machine resources. This is where the `fetch-containers` subcommand steps in. It is designed to work exactly like `build-containers` but instead the images, pre-built, are fetched from an image registry then re-tagged for deployment. It can be used in place of `build-containers` for any stack provided the necessary containers, built for the local machine architecture (e.g. arm64 or x86-64) have already been published in an image registry.
+## Usage
+To use `fetch-containers`, provide an image registry path, a username and token/password with read access to the registry, and optionally specify `--force-local-overwrite`. If this argument is not specified, if there is already a locally built or previously fetched image for a stack container on the machine, it will not be overwritten and a warning issued.
+```
+$ laconic-so --stack mobymask-v3-demo fetch-containers --image-registry git.vdb.to/cerc-io --registry-username <registry-user> --registry-token <registry-token> --force-local-overwrite
+```

docs/gitea-with-laconicd-fixturenet.md

@@ -0,0 +1,80 @@
+# Gitea x NPMs X Laconicd
+
+Deploy a local Gitea server, publish NPM packages to it, then use those packages to build a Laconicd fixturenet. Demonstrates several components of the Laconic stack
+
+### Build and Deploy Gitea
+
+```bash
+laconic-so --stack build-support build-containers
+laconic-so --stack package-registry setup-repositories
+laconic-so --stack package-registry build-containers 
+laconic-so --stack package-registry deploy up
+```
+
+These commands can take awhile. Eventually, some instructions and a token will output. Set `CERC_NPM_AUTH_TOKEN`:
+
+```bash
+export CERC_NPM_AUTH_TOKEN=<your-token>
+```
+
+### Configure the hostname gitea.local
+
+How to do this depends on your operating system  but usually involves editing a `hosts` file. For example, on Linux add this line to the file `/etc/hosts` (needs sudo):
+
+```bash
+127.0.0.1       gitea.local
+```
+
+Test with:
+
+```bash
+ping gitea.local
+```
+
+```bash
+PING gitea.local (127.0.0.1) 56(84) bytes of data.
+64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.147 ms
+64 bytes from localhost (127.0.0.1): icmp_seq=2 ttl=64 time=0.033 ms
+```
+
+Although not necessary in order to build and publish packages, you can now access the Gitea web interface at: [http://gitea.local:3000](http://gitea.local:3000) using these credentials: `gitea_admin/admin1234` (Note: please properly secure Gitea if public internet access is allowed).
+
+### Build npm Packages
+
+Clone the required repositories:
+
+```bash
+laconic-so --stack fixturenet-laconicd setup-repositories
+```
+
+Build and publish the npm packages:
+
+```bash
+laconic-so --stack fixturenet-laconicd build-npms
+```
+
+Navigate to the Gitea console and switch to the `cerc-io` user then find the `Packages` tab to confirm that these two npm packages have been published:
+
+- `@cerc-io/laconic-registry-cli`
+- `@cerc-io/registry-sdk`
+
+### Build and deploy fixturenet containers
+
+```bash
+laconic-so --stack fixturenet-laconicd build-containers
+laconic-so --stack fixturenet-laconicd deploy up
+```
+
+Check the logs:
+
+```bash
+laconic-so --stack fixturenet-laconicd deploy logs
+```
+
+### Test with the registry CLI
+
+```bash
+laconic-so --stack fixturenet-laconicd deploy exec cli "laconic registry status"
+```
+
+Try additional CLI commands, documented [here](https://github.com/cerc-io/laconic-registry-cli#operations).

docs/k8s-deployment-enhancements.md

@@ -0,0 +1,27 @@
+# K8S Deployment Enhancements
+## Controlling pod placement
+The placement of pods created as part of a stack deployment can be controlled to either avoid certain nodes, or require certain nodes.
+### Pod/Node Affinity
+Node affinity rules applied to pods target node labels. The effect is that a pod can only be placed on a node having the specified label value. Note that other pods that do not have any node affinity rules can also be placed on those same nodes. Thus node affinity for a pod controls where that pod can be placed, but does not control where other pods are placed.
+
+Node affinity for stack pods is specified in the deployment's `spec.yml` file as follows:
+```
+node-affinities:
+  - label: nodetype
+    value: typeb
+```
+This example denotes that the stack's pods should only be placed on nodes that have the label `nodetype` with value `typeb`.
+### Node Taint Toleration
+K8s nodes can be given one or more "taints". These are special fields (distinct from labels) with a name (key) and optional value.
+When placing pods, the k8s scheduler will only assign a pod to a tainted node if the pod posesses a corresponding "toleration".
+This is metadata associated with the pod that specifies that the pod "tolerates" a given taint.
+Therefore taint toleration provides a mechanism by which only certain pods can be placed on specific nodes, and provides a complementary mechanism to node affinity.
+
+Taint toleration for stack pods is specified in the deployment's `spec.yml` file as follows:
+```
+node-tolerations:
+  - key: nodetype
+    value: typeb
+```
+This example denotes that the stack's pods will tolerate a taint: `nodetype=typeb`
+

docs/laconicd-fixturenet.md

@@ -1,220 +0,0 @@
-# Running a laconicd fixturenet with console
-
-The following tutorial explains the steps to run a laconicd fixturenet with CLI and web console that displays records in the registry. It is designed as an introduction to Stack Orchestrator and to showcase one component of the Laconic Stack. Prior to Stack Orchestrator, the following 4 repositories had to be cloned and setup manually:
-
-- https://github.com/cerc-io/laconicd
-- https://github.com/cerc-io/laconic-sdk
-- https://github.com/cerc-io/laconic-registry-cli
-- https://github.com/cerc-io/laconic-console
-
-Now, with Stack Orchestrator, it is a few quick commands. Additionally, the `docker` and `docker compose` integration on the back-end allows the stack to easily persist, facilitating workflows.
-
-## Setup laconic-so
-
-To avoid hiccups on Mac M1/M2 and any local machine nuances that may affect the user experience, this tutorial is focused on using a fresh Digital Ocean (DO) droplet with similar specs: 
-16 GB Memory / 8 Intel vCPUs / 160 GB Disk.
-
-1. Login to the droplet as root (either by SSH key or password set in the DO console)
-
-```
-ssh root@IP
-```
-
-2. Get the install script, give it executable permissions, and run it:
-
-```
-curl -o install.sh https://raw.githubusercontent.com/cerc-io/stack-orchestrator/main/scripts/quick-install-linux.sh
-```
-```
-chmod +x install.sh
-```
-```
-bash install.sh
-```
-
-3. Confirm docker was installed and activate the changes in `~/.profile`:
-
-```
-docker run hello-world
-```
-```
-source ~/.profile
-```
-
-4. Verify installation:
-
-```
-laconic-so version
-```
-
-## Setup the laconic fixturenet stack
-
-1. Get the repositories
-
-```
-laconic-so --stack fixturenet-laconic-loaded setup-repositories --include github.com/cerc-io/laconicd,github.com/cerc-io/laconic-sdk,github.com/cerc-io/laconic-registry-cli,github.com/cerc-io/laconic-console
-```
-
-2. Set this environment variable to the Laconic self-hosted Gitea instance:
-
-```
-export CERC_NPM_REGISTRY_URL=https://git.vdb.to/api/packages/cerc-io/npm/
-```
-
-3. Build the containers:
-
-```
-laconic-so --stack fixturenet-laconic-loaded build-containers
-```
-
-It's possible to run into an `ESOCKETTIMEDOUT` error, e.g., `error An unexpected error occurred: "https://registry.yarnpkg.com/@material-ui/icons/-/icons-4.11.3.tgz: ESOCKETTIMEDOUT"`. This may happen even if you have a great internet connection. In that case, re-run the `build-containers` command.
-
-4. Set this environment variable to your droplet's IP address:
-
-```
-export LACONIC_HOSTED_ENDPOINT=http://<your-IP>
-```
-
-5. Deploy the stack:
-
-```
-laconic-so --stack fixturenet-laconic-loaded deploy up
-```
-
-6. Check the logs:
-
-```
-laconic-so --stack fixturenet-laconic-loaded deploy logs
-```
-
-You'll see output from `laconicd` and the block height should be >1 to confirm it is running:
-
-```
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:29PM INF indexed block exents height=12 module=txindex server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF Timed out dur=4976.960115 height=13 module=consensus round=0 server=node step=1
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF received proposal module=consensus proposal={"Type":32,"block_id":{"hash":"D26C088A711F912ADB97888C269F628DA33153795621967BE44DCB43C3D03CA4","parts":{"hash":"22411A20B7F14CDA33244420FBDDAF24450C0628C7A06034FF22DAC3699DDCC8","total":1}},"height":13,"pol_round":-1,"round":0,"signature":"DEuqnaQmvyYbUwckttJmgKdpRu6eVm9i+9rQ1pIrV2PidkMNdWRZBLdmNghkIrUzGbW8Xd7UVJxtLRmwRASgBg==","timestamp":"2023-04-18T21:30:01.49450663Z"} server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF received complete proposal block hash=D26C088A711F912ADB97888C269F628DA33153795621967BE44DCB43C3D03CA4 height=13 module=consensus server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF finalizing commit of block hash={} height=13 module=consensus num_txs=0 root=1A8CA1AF139CCC80EC007C6321D8A63A46A793386EE2EDF9A5CA0AB2C90728B7 server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF minted coins from module account amount=2059730459416582643aphoton from=mint module=x/bank
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF executed block height=13 module=state num_invalid_txs=0 num_valid_txs=0 server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF commit synced commit=436F6D6D697449447B5B363520313037203630203232372039352038352032303820313334203231392032303520313433203130372031343920313431203139203139322038362031323720362031383520323533203137362031333820313735203135392031383620323334203135382031323120313431203230342037335D3A447D
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF committed state app_hash=416B3CE35F55D086DBCD8F6B958D13C0567F06B9FDB08AAF9FBAEA9E798DCC49 height=13 module=state num_txs=0 server=node
-laconic-5cd0a80c1442c3044c8b295d26426bae-laconicd-1         | 9:30PM INF indexed block exents height=13 module=txindex server=node
-```
-
-7. Confirm operation of the registry CLI:
-
-```
-laconic-so --stack fixturenet-laconic-loaded deploy exec cli "laconic cns status"
-```
-
-```
-{
-  "version": "0.3.0",
-  "node": {
-    "id": "4216af2ac9f68bda33a38803fc1b5c9559312c1d",
-    "network": "laconic_9000-1",
-    "moniker": "localtestnet"
-  },
-  "sync": {
-    "latest_block_hash": "1BDF4CB9AE2390DA65BCF997C83133C18014FCDDCAE03708488F0B56FCEEA429",
-    "latest_block_height": "5",
-    "latest_block_time": "2023-08-09 16:00:30.386903172 +0000 UTC",
-    "catching_up": false
-  },
-  "validator": {
-    "address": "651FBC700B747C76E90ACFC18CC9508C3D0905B9",
-    "voting_power": "1000000000000000"
-  },
-  "validators": [
-    {
-      "address": "651FBC700B747C76E90ACFC18CC9508C3D0905B9",
-      "voting_power": "1000000000000000",
-      "proposer_priority": "0"
-    }
-  ],
-  "num_peers": "0",
-  "peers": [],
-  "disk_usage": "292.0K"
-}
-```
-
-## Configure Digital Ocean firewall
-
-Let's open some ports.
-
-1. In the Digital Ocean web console, navigate to your droplet's main page. Select the "Networking" tab and scroll down to "Firewall".
-
-2. Get the port for the running console:
-
-```
-echo http://IP:$(laconic-so --stack fixturenet-laconic-loaded deploy port laconic-console 80 | cut -d ':' -f 2)
-```
-```
-http://IP:32778
-```
-
-3. Go back to the Digital Ocean web console and set an Inbound Rule for Custom TCP of the above port:
-
-- `32778` in this example, but yours will be different.
-- do the same for port `9473`
-
-Additional ports will need to be opened depending on your application. Ensure you add your droplet to this new Firewall and wait a minute or so for the update to propagate.
-
-4. Navigate to http://IP:port and ensure laconic-console is functioning as expected:
-
-- ensure you are connected to `laconicd`; no error message should pop up;
-- the wifi symbol in the bottom right should have a green check mark beside it
-- navigate to the status tab; it should display similar/identical information
-- navigate to the config tab, you'll see something like (with your IP):
-
-```
-wns
-  webui http://68.183.195.210:9473/console
-  server http://68.183.195.210:9473/api
-```
-
-## Publish and query a sample record to the registry
-
-1. The following command will create a bond and publish a record:
-
-```
-laconic-so --stack fixturenet-laconic-loaded deploy exec cli ./scripts/create-demo-records.sh
-```
-
-You'll get an output like:
-
-```
-Balance is: 99998999999999998999600000
-Created bond with id: dd88e8d6f9567b32b28e70552aea4419c5dd3307ebae85a284d1fe38904e301a
-Published demo-record-1.yml with id: bafyreierh3xnfivexlscdwubvczmddsnf46uytyfvrbdhkjzztvsz6ruly
-```
-
-The sample record we deployed looks like:
-
-```
-record:
-  type: WebsiteRegistrationRecord
-  url: 'https://cerc.io'
-  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
-  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
-  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
-  version: 1.0.23
-```
-
-2. Return to the laconic-console
-
-- the published record should now be viewable
-- explore it for more information
-- click on the link that opens the GraphQL console
-- the query is pre-loaded, click the button to run it
-- inspect the output
-
-3. Try out additional CLI commands
-
-- these are documented [here](https://github.com/cerc-io/laconic-registry-cli#readme) and updates are forthcoming
-- e.g,:
-
-```
-laconic-so --stack fixturenet-laconic-loaded deploy exec cli "laconic cns record list"
-```

docs/laconicd-with-console.md

@@ -0,0 +1,227 @@
+# Running a laconicd fixturenet with console
+
+The following tutorial explains the steps to run a laconicd fixturenet with CLI and web console that displays records in the registry. It is designed as an introduction to Stack Orchestrator and to showcase one component of the Laconic Stack. Prior to Stack Orchestrator, the following repositories had to be cloned and setup manually:
+
+- https://git.vdb.to/cerc-io/laconicd
+- https://git.vdb.to/cerc-io/laconic-registry-cli
+- https://git.vdb.to/cerc-io/laconic-console
+
+Now, with Stack Orchestrator, it is a few quick commands. Additionally, the `docker` and `docker compose` integration on the back-end allows the stack to easily persist, facilitating workflows.
+
+## Setup laconic-so
+
+To avoid hiccups on Mac M1/M2 and any local machine nuances that may affect the user experience, this tutorial is focused on using a fresh Digital Ocean (DO) droplet with similar specs:
+16 GB Memory / 8 Intel vCPUs / 160 GB Disk.
+
+1. Login to the droplet as root (either by SSH key or password set in the DO console)
+    ```
+    ssh root@IP
+    ```
+
+1. Get the install script, give it executable permissions, and run it:
+
+    ```
+    curl -o install.sh https://raw.githubusercontent.com/cerc-io/stack-orchestrator/main/scripts/quick-install-linux.sh
+    ```
+    ```
+    chmod +x install.sh
+    ```
+    ```
+    bash install.sh
+    ```
+
+1. Confirm docker was installed and activate the changes in `~/.profile`:
+
+    ```
+    docker run hello-world
+   ```
+   ```
+   source ~/.profile
+   ```
+
+1. Verify installation:
+
+    ```
+    laconic-so version
+    ```
+
+## Setup the laconic fixturenet stack
+
+1. Get the repositories
+
+    ```
+    laconic-so --stack fixturenet-laconic-loaded setup-repositories --include git.vdb.to/cerc-io/laconicd
+    ```
+
+1. Build the containers:
+
+    ```
+    laconic-so --stack fixturenet-laconic-loaded build-containers
+    ```
+
+    It's possible to run into an `ESOCKETTIMEDOUT` error, e.g., `error An unexpected error occurred: "https://registry.yarnpkg.com/@material-ui/icons/-/icons-4.11.3.tgz: ESOCKETTIMEDOUT"`. This may happen even if you have a great internet connection. In that case, re-run the `build-containers` command.
+
+
+1. Set this environment variable to your droplet's IP address or fully qualified DNS host name if it has one:
+
+    ```
+    export BACKEND_ENDPOINT=http://<your-IP-or-hostname>:9473
+    ```
+    e.g.
+    ```
+    export BACKEND_ENDPOINT=http://my-test-server.example.com:9473
+    ```
+
+1. Create a deployment directory for the stack:
+    ```
+    laconic-so --stack fixturenet-laconic-loaded deploy init --output laconic-loaded.spec --map-ports-to-host any-same --config LACONIC_HOSTED_ENDPOINT=$BACKEND_ENDPOINT
+
+    # Update port mapping in the laconic-loaded.spec file to resolve port conflicts on host if any
+    ```
+    ```
+    laconic-so --stack fixturenet-laconic-loaded deploy create --deployment-dir laconic-loaded-deployment --spec-file laconic-loaded.spec
+    ```
+2. Start the stack:
+
+    ```
+    laconic-so deployment --dir laconic-loaded-deployment start
+    ```
+
+3. Check the logs:
+
+    ```
+    laconic-so deployment --dir laconic-loaded-deployment logs
+    ```
+
+    You'll see output from `laconicd` and the block height should be >1 to confirm it is running:
+
+    ```
+    laconicd-1         | 6:12AM INF indexed block events height=16 module=txindex
+    laconicd-1         | 6:12AM INF Timed out dur=2993.893332 height=17 module=consensus round=0 step=RoundStepNewHeight
+    laconicd-1         | 6:12AM INF received proposal module=consensus proposal="Proposal{17/0 (E15D03C180CE607AE8340A1325A0C134DFB4E1ADD992E173C701EBD362523267:1:DF138772FEF0, -1) 6A6F3B0A42B3 @ 2024-07-25T06:12:31.952967053Z}" proposer=86970D950BC9C16F3991A52D9C6DC55BA478A7C6
+    laconicd-1         | 6:12AM INF received complete proposal block hash=E15D03C180CE607AE8340A1325A0C134DFB4E1ADD992E173C701EBD362523267 height=17 module=consensus
+    laconicd-1         | 6:12AM INF finalizing commit of block hash=E15D03C180CE607AE8340A1325A0C134DFB4E1ADD992E173C701EBD362523267 height=17 module=consensus num_txs=0 root=AF4941107DC718ED1425E77A3DC7F1154FB780B7A7DE20288DC43442203527E3
+    laconicd-1         | 6:12AM INF finalized block block_app_hash=26A665360BB1EE64E54F97F2A5AB7F621B33A86D9896574000C05DE63F43F788 height=17 module=state num_txs_res=0 num_val_updates=0
+    laconicd-1         | 6:12AM INF executed block app_hash=26A665360BB1EE64E54F97F2A5AB7F621B33A86D9896574000C05DE63F43F788 height=17 module=state
+    laconicd-1         | 6:12AM INF committed state block_app_hash=AF4941107DC718ED1425E77A3DC7F1154FB780B7A7DE20288DC43442203527E3 height=17 module=state
+    laconicd-1         | 6:12AM INF indexed block events height=17 module=txindex
+    ```
+
+4. Confirm operation of the registry CLI:
+
+   ```
+   laconic-so deployment --dir laconic-loaded-deployment exec cli "laconic registry status"
+   ```
+
+   ```
+   {
+     "version": "0.3.0",
+     "node": {
+       "id": "6e072894aa1f5d9535a1127a0d7a7f8e65100a2c",
+       "network": "laconic_9000-1",
+       "moniker": "localtestnet"
+     },
+     "sync": {
+       "latestBlockHash": "260102C283D0411CFBA0270F7DC182650FFCA737A2F6F652A985F6065696F590",
+       "latestBlockHeight": "49",
+       "latestBlockTime": "2024-07-25 06:14:05.626744215 +0000 UTC",
+       "catchingUp": false
+     },
+     "validator": {
+       "address": "86970D950BC9C16F3991A52D9C6DC55BA478A7C6",
+       "votingPower": "1000000000000000"
+     },
+     "validators": [
+       {
+         "address": "86970D950BC9C16F3991A52D9C6DC55BA478A7C6",
+         "votingPower": "1000000000000000",
+         "proposerPriority": "0"
+       }
+     ],
+     "numPeers": "0",
+     "peers": [],
+     "diskUsage": "688K"
+   }
+   ```
+
+## Configure Digital Ocean firewall
+
+(Note this step may not be necessary depending on the droplet image used)
+
+Let's open some ports.
+
+1. In the Digital Ocean web console, navigate to your droplet's main page. Select the "Networking" tab and scroll down to "Firewall".
+
+2. Get the port for the running console:
+
+```
+echo http://IP:$(laconic-so --stack fixturenet-laconic-loaded deploy port laconic-console 80 | cut -d ':' -f 2)
+```
+```
+http://IP:32778
+```
+
+3. Go back to the Digital Ocean web console and set an Inbound Rule for Custom TCP of the above port:
+
+- `32778` in this example, but yours will be different.
+- do the same for port `9473`
+
+Additional ports will need to be opened depending on your application. Ensure you add your droplet to this new Firewall and wait a minute or so for the update to propagate.
+
+4. Navigate to http://IP:port and ensure laconic-console is functioning as expected:
+
+- ensure you are connected to `laconicd`; no error message should pop up;
+- the wifi symbol in the bottom right should have a green check mark beside it
+- navigate to the status tab; it should display similar/identical information
+- navigate to the config tab, you'll see something like (with your IP):
+
+```
+wns
+  webui http://68.183.195.210:9473/console
+  server http://68.183.195.210:9473/api
+```
+
+## Publish and query a sample record to the registry
+
+1. The following command will create a bond and publish a record:
+
+```
+laconic-so deployment --dir laconic-loaded-deployment exec cli ./scripts/create-demo-records.sh
+```
+
+You'll get an output like:
+
+```
+Balance is: 9.9999e+25
+Created bond with id: dd88e8d6f9567b32b28e70552aea4419c5dd3307ebae85a284d1fe38904e301a
+Published demo-record-1.yml with id: bafyreierh3xnfivexlscdwubvczmddsnf46uytyfvrbdhkjzztvsz6ruly
+```
+
+The sample record we deployed looks like:
+
+```
+record:
+  type: WebsiteRegistrationRecord
+  url: 'https://cerc.io'
+  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
+  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
+  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
+  version: 1.0.23
+```
+
+2. Return to the laconic-console
+
+- the published record should now be viewable
+- explore it for more information
+- click on the link that opens the GraphQL console
+- the query is pre-loaded, click the button to run it
+- inspect the output
+
+3. Try out additional CLI commands
+
+- these are documented [here](https://git.vdb.to/cerc-io/laconic-registry-cli#readme) and updates are forthcoming
+- e.g,:
+
+```
+laconic-so deployment --dir laconic-loaded-deployment exec cli "laconic registry record list"
+```

docs/spec.md

@@ -1,7 +1,6 @@
 # Specification
 
-(note this page is out of date)
+Note: this page is out of date (but still useful) - it will no longer be useful once stacks are [decoupled from the tool functionality](https://git.vdb.to/cerc-io/stack-orchestrator/issues/315).
-
 
 ## Implementation
 

docs/webapp.md

@@ -0,0 +1,64 @@
+### Building and Running Webapps
+
+It is possible to build and run Next.js webapps using the `build-webapp` and `run-webapp` subcommands.
+
+To make it easier to build once and deploy into different environments and with different configuration,
+compilation and static page generation are separated in the `build-webapp` and `run-webapp` steps.
+
+This offers much more flexibilty than standard Next.js build methods, since any environment variables accessed
+via `process.env`, whether for pages or for API, will have values drawn from their runtime deployment environment,
+not their build environment. 
+
+## Building
+
+Building usually requires no additional configuration.  By default, the Next.js version specified in `package.json`
+is used, and either `yarn` or `npm` will be used automatically depending on which lock files are present.  These
+can be overidden with the build arguments `CERC_NEXT_VERSION` and `CERC_BUILD_TOOL` respectively.  For example: `--extra-build-args "--build-arg CERC_NEXT_VERSION=13.4.12"`
+
+**Example**:
+```
+$ cd ~/cerc
+$ git clone git@git.vdb.to:cerc-io/test-progressive-web-app.git
+$ laconic-so build-webapp --source-repo ~/cerc/test-progressive-web-app
+...
+
+Built host container for ~/cerc/test-progressive-web-app with tag:
+
+    cerc/test-progressive-web-app:local
+
+To test locally run:
+
+    laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment.env
+
+```
+
+## Running
+
+With `run-webapp` a new container will be launched on the local machine, with runtime configuration provided by `--env-file` (if specified) and published on an available port.  Multiple instances can be launched with different configuration.
+
+**Example**:
+```
+# Production env
+$ laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment/production.env
+
+Image: cerc/test-progressive-web-app:local
+ID: 4c6e893bf436b3e91a2b92ce37e30e499685131705700bd92a90d2eb14eefd05
+URL: http://localhost:32768
+
+# Dev env
+$ laconic-so run-webapp --image cerc/test-progressive-web-app:local --env-file /path/to/environment/dev.env
+
+Image: cerc/test-progressive-web-app:local
+ID: 9ab96494f563aafb6c057d88df58f9eca81b90f8721a4e068493a289a976051c
+URL: http://localhost:32769
+```
+
+## Deploying
+
+Use the subcommand `deploy-webapp create` to make a deployment directory that can be subsequently deployed to a Kubernetes cluster.
+Example commands are shown below, assuming that the webapp container image `cerc/test-progressive-web-app:local` has already been built:
+```
+$ laconic-so deploy-webapp create --kube-config ~/kubectl/k8s-kubeconfig.yaml --image-registry registry.digitalocean.com/laconic-registry --deployment-dir webapp-k8s-deployment --image cerc/test-progressive-web-app:local --url https://test-pwa-app.hosting.laconic.com/ --env-file test-webapp.env
+$ laconic-so deployment --dir webapp-k8s-deployment push-images
+$ laconic-so deployment --dir webapp-k8s-deployment start
+```

requirements.txt

@@ -1,4 +1,5 @@
 python-decouple>=3.8
+python-dotenv==1.0.0
 GitPython>=3.1.32
 tqdm>=4.65.0
 python-on-whales>=0.64.0
@@ -8,3 +9,7 @@ ruamel.yaml>=0.17.32
 pydantic==1.10.9
 tomli==2.0.1
 validators==0.22.0
+kubernetes>=28.1.0
+humanfriendly>=10.0
+python-gnupg>=0.5.2
+requests>=2.3.2

scripts/cloud-init-dev-mode-install.yaml

@@ -41,4 +41,4 @@ runcmd:
   - apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
   - systemctl enable docker
   - systemctl start docker
-  - git clone https://github.com/cerc-io/stack-orchestrator.git /home/ubuntu/stack-orchestrator
+  - git clone https://git.vdb.to/cerc-io/stack-orchestrator.git /home/ubuntu/stack-orchestrator

scripts/cloud-init-user-mode-install.yaml

@@ -31,5 +31,5 @@ runcmd:
   - apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
   - systemctl enable docker
   - systemctl start docker
-  - curl -L -o /usr/local/bin/laconic-so https://github.com/cerc-io/stack-orchestrator/releases/latest/download/laconic-so
+  - curl -L -o /usr/local/bin/laconic-so https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
   - chmod +x /usr/local/bin/laconic-so

scripts/create_build_tag_file.sh

@@ -1,6 +1,6 @@
-build_tag_file_name=./app/data/build_tag.txt
+build_tag_file_name=./stack_orchestrator/data/build_tag.txt
 echo "# This file should be re-generated running: scripts/create_build_tag_file.sh script" > $build_tag_file_name
-product_version_string=$( tail -1 ./app/data/version.txt )
+product_version_string=$( tail -1 ./stack_orchestrator/data/version.txt )
 commit_string=$( git rev-parse --short HEAD )
 timestamp_string=$(date +'%Y%m%d%H%M')
 build_tag_string=${product_version_string}-${commit_string}-${timestamp_string}

scripts/quick-deploy-test.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Beginnings of a script to quickly spin up and test a deployment
+if [[ -n "$CERC_SCRIPT_DEBUG" ]]; then
+    set -x
+fi
+if [[ -n "$1" ]]; then
+	stack_name=$1
+else
+	stack_name="test"
+fi
+spec_file_name="${stack_name}-spec.yml"
+deployment_dir_name="${stack_name}-deployment"
+rm -f ${spec_file_name}
+rm -rf ${deployment_dir_name}
+laconic-so --stack ${stack_name} deploy --deploy-to compose init --output ${spec_file_name}
+laconic-so --stack ${stack_name} deploy --deploy-to compose create --deployment-dir ${deployment_dir_name} --spec-file ${spec_file_name}
+#laconic-so deployment --dir ${deployment_dir_name} start
+#laconic-so deployment --dir ${deployment_dir_name} ps
+#laconic-so deployment --dir ${deployment_dir_name} stop

scripts/quick-install-linux.sh

@@ -137,7 +137,7 @@ fi
 echo "**************************************************************************************"
 echo "Installing laconic-so"
 # install latest `laconic-so`
-distribution_url=https://github.com/cerc-io/stack-orchestrator/releases/latest/download/laconic-so
+distribution_url=https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
 install_filename=${install_dir}/laconic-so
 mkdir -p  ${install_dir}
 curl -L -o ${install_filename} ${distribution_url}

setup.py

@@ -4,17 +4,19 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 with open("requirements.txt", "r", encoding="utf-8") as fh:
     requirements = fh.read()
+with open("stack_orchestrator/data/version.txt", "r", encoding="utf-8") as fh:
+    version = fh.readlines()[-1].strip(" \n")
 setup(
     name='laconic-stack-orchestrator',
-    version='1.0.12',
+    version=version,
     author='Cerc',
     author_email='info@cerc.io',
     license='GNU Affero General Public License',
     description='Orchestrates deployment of the Laconic stack',
     long_description=long_description,
     long_description_content_type="text/markdown",
-    url='https://github.com/cerc-io/stack-orchestrator',
+    url='https://git.vdb.to/cerc-io/stack-orchestrator',
-    py_modules=['cli', 'app'],
+    py_modules=['stack_orchestrator'],
     packages=find_packages(),
     install_requires=[requirements],
     python_requires='>=3.7',
@@ -25,6 +27,6 @@ setup(
         "Operating System :: OS Independent",
     ],
     entry_points={
-        'console_scripts': ['laconic-so=cli:cli'],
+        'console_scripts': ['laconic-so=stack_orchestrator.main:cli'],
     }
 )

stack_orchestrator/base.py

@@ -15,7 +15,7 @@
 
 import os
 from abc import ABC, abstractmethod
-from app.deploy import get_stack_status
+from stack_orchestrator.deploy.deploy import get_stack_status
 from decouple import config
 
 

stack_orchestrator/build/build_containers.py

@@ -0,0 +1,183 @@
+# Copyright © 2022, 2023 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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/>.
+
+# Builds or pulls containers for the system components
+
+# env vars:
+# CERC_REPO_BASE_DIR defaults to ~/cerc
+
+# TODO: display the available list of containers; allow re-build of either all or specific containers
+
+import os
+import sys
+from decouple import config
+import subprocess
+import click
+from pathlib import Path
+from stack_orchestrator.opts import opts
+from stack_orchestrator.util import include_exclude_check, stack_is_external, error_exit
+from stack_orchestrator.base import get_npm_registry_url
+from stack_orchestrator.build.build_types import BuildContext
+from stack_orchestrator.build.publish import publish_image
+from stack_orchestrator.build.build_util import get_containers_in_scope
+
+# TODO: find a place for this
+#    epilog="Config provided either in .env or settings.ini or env vars: CERC_REPO_BASE_DIR (defaults to ~/cerc)"
+
+
+def make_container_build_env(dev_root_path: str,
+                             container_build_dir: str,
+                             debug: bool,
+                             force_rebuild: bool,
+                             extra_build_args: str):
+    container_build_env = {
+        "CERC_NPM_REGISTRY_URL": get_npm_registry_url(),
+        "CERC_GO_AUTH_TOKEN": config("CERC_GO_AUTH_TOKEN", default=""),
+        "CERC_NPM_AUTH_TOKEN": config("CERC_NPM_AUTH_TOKEN", default=""),
+        "CERC_REPO_BASE_DIR": dev_root_path,
+        "CERC_CONTAINER_BASE_DIR": container_build_dir,
+        "CERC_HOST_UID": f"{os.getuid()}",
+        "CERC_HOST_GID": f"{os.getgid()}",
+        "DOCKER_BUILDKIT": config("DOCKER_BUILDKIT", default="0")
+    }
+    container_build_env.update({"CERC_SCRIPT_DEBUG": "true"} if debug else {})
+    container_build_env.update({"CERC_FORCE_REBUILD": "true"} if force_rebuild else {})
+    container_build_env.update({"CERC_CONTAINER_EXTRA_BUILD_ARGS": extra_build_args} if extra_build_args else {})
+    docker_host_env = os.getenv("DOCKER_HOST")
+    if docker_host_env:
+        container_build_env.update({"DOCKER_HOST": docker_host_env})
+
+    return container_build_env
+
+
+def process_container(build_context: BuildContext) -> bool:
+    if not opts.o.quiet:
+        print(f"Building: {build_context.container}")
+
+    default_container_tag = f"{build_context.container}:local"
+    build_context.container_build_env.update({"CERC_DEFAULT_CONTAINER_IMAGE_TAG": default_container_tag})
+
+    # Check if this is in an external stack
+    if stack_is_external(build_context.stack):
+        container_parent_dir = Path(build_context.stack).parent.parent.joinpath("container-build")
+        temp_build_dir = container_parent_dir.joinpath(build_context.container.replace("/", "-"))
+        temp_build_script_filename = temp_build_dir.joinpath("build.sh")
+        # Now check if the container exists in the external stack.
+        if not temp_build_script_filename.exists():
+            # If not, revert to building an internal container
+            container_parent_dir = build_context.container_build_dir
+    else:
+        container_parent_dir = build_context.container_build_dir
+
+    build_dir = container_parent_dir.joinpath(build_context.container.replace("/", "-"))
+    build_script_filename = build_dir.joinpath("build.sh")
+
+    if opts.o.verbose:
+        print(f"Build script filename: {build_script_filename}")
+    if os.path.exists(build_script_filename):
+        build_command = build_script_filename.as_posix()
+    else:
+        if opts.o.verbose:
+            print(f"No script file found: {build_script_filename}, using default build script")
+        repo_dir = build_context.container.split('/')[1]
+        # TODO: make this less of a hack -- should be specified in some metadata somewhere
+        # Check if we have a repo for this container. If not, set the context dir to the container-build subdir
+        repo_full_path = os.path.join(build_context.dev_root_path, repo_dir)
+        repo_dir_or_build_dir = repo_full_path if os.path.exists(repo_full_path) else build_dir
+        build_command = os.path.join(build_context.container_build_dir,
+                                     "default-build.sh") + f" {default_container_tag} {repo_dir_or_build_dir}"
+    if not opts.o.dry_run:
+        # No PATH at all causes failures with podman.
+        if "PATH" not in build_context.container_build_env:
+            build_context.container_build_env["PATH"] = os.environ["PATH"]
+        if opts.o.verbose:
+            print(f"Executing: {build_command} with environment: {build_context.container_build_env}")
+        build_result = subprocess.run(build_command, shell=True, env=build_context.container_build_env)
+        if opts.o.verbose:
+            print(f"Return code is: {build_result.returncode}")
+        if build_result.returncode != 0:
+            return False
+        else:
+            return True
+    else:
+        print("Skipped")
+        return True
+
+
+@click.command()
+@click.option('--include', help="only build these containers")
+@click.option('--exclude', help="don\'t build these containers")
+@click.option("--force-rebuild", is_flag=True, default=False, help="Override dependency checking -- always rebuild")
+@click.option("--extra-build-args", help="Supply extra arguments to build")
+@click.option("--publish-images", is_flag=True, default=False, help="Publish the built images in the specified image registry")
+@click.option("--image-registry", help="Specify the image registry for --publish-images")
+@click.pass_context
+def command(ctx, include, exclude, force_rebuild, extra_build_args, publish_images, image_registry):
+    '''build the set of containers required for a complete stack'''
+
+    local_stack = ctx.obj.local_stack
+    stack = ctx.obj.stack
+
+    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
+    container_build_dir = Path(__file__).absolute().parent.parent.joinpath("data", "container-build")
+
+    if local_stack:
+        dev_root_path = os.getcwd()[0:os.getcwd().rindex("stack-orchestrator")]
+        print(f'Local stack dev_root_path (CERC_REPO_BASE_DIR) overridden to: {dev_root_path}')
+    else:
+        dev_root_path = os.path.expanduser(config("CERC_REPO_BASE_DIR", default="~/cerc"))
+
+    if not opts.o.quiet:
+        print(f'Dev Root is: {dev_root_path}')
+
+    if not os.path.isdir(dev_root_path):
+        print('Dev root directory doesn\'t exist, creating')
+
+    if publish_images:
+        if not image_registry:
+            error_exit("--image-registry must be supplied with --publish-images")
+
+    containers_in_scope = get_containers_in_scope(stack)
+
+    container_build_env = make_container_build_env(dev_root_path,
+                                                   container_build_dir,
+                                                   opts.o.debug,
+                                                   force_rebuild,
+                                                   extra_build_args)
+
+    for container in containers_in_scope:
+        if include_exclude_check(container, include, exclude):
+
+            build_context = BuildContext(
+                stack,
+                container,
+                container_build_dir,
+                container_build_env,
+                dev_root_path
+            )
+            result = process_container(build_context)
+            if result:
+                if publish_images:
+                    publish_image(f"{container}:local", image_registry)
+            else:
+                print(f"Error running build for {build_context.container}")
+                if not opts.o.continue_on_error:
+                    error_exit("container build failed and --continue-on-error not set, exiting")
+                    sys.exit(1)
+                else:
+                    print("****** Container Build Error, continuing because --continue-on-error is set")
+        else:
+            if opts.o.verbose:
+                print(f"Excluding: {container}")

stack_orchestrator/build/build_npms.py

@@ -25,8 +25,8 @@ from decouple import config
 import click
 import importlib.resources
 from python_on_whales import docker, DockerException
-from app.base import get_stack
+from stack_orchestrator.base import get_stack
-from app.util import include_exclude_check, get_parsed_stack_config
+from stack_orchestrator.util import include_exclude_check, get_parsed_stack_config
 
 builder_js_image_name = "cerc/builder-js:local"
 
@@ -83,7 +83,7 @@ def command(ctx, include, exclude, force_rebuild, extra_build_args):
         os.makedirs(build_root_path)
 
     # See: https://stackoverflow.com/a/20885799/1701505
-    from app import data
+    from stack_orchestrator import data
     with importlib.resources.open_text(data, "npm-package-list.txt") as package_list_file:
         all_packages = package_list_file.read().splitlines()
 

stack_orchestrator/build/build_types.py

@@ -0,0 +1,29 @@
+# Copyright © 2024 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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 dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping
+
+
+@dataclass
+class BuildContext:
+    stack: str
+    container: str
+    container_build_dir: Path
+    container_build_env: Mapping[str,str]
+    dev_root_path: str
+

stack_orchestrator/build/build_util.py

@@ -0,0 +1,41 @@
+# Copyright © 2024 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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/>.
+
+import importlib.resources
+
+from stack_orchestrator.opts import opts
+from stack_orchestrator.util import get_parsed_stack_config, warn_exit
+
+
+def get_containers_in_scope(stack: str):
+
+    containers_in_scope = []
+    if stack:
+        stack_config = get_parsed_stack_config(stack)
+        if "containers" not in stack_config or stack_config["containers"] is None:
+            warn_exit(f"stack {stack} does not define any containers")
+        containers_in_scope = stack_config['containers']
+    else:
+        # See: https://stackoverflow.com/a/20885799/1701505
+        from stack_orchestrator import data
+        with importlib.resources.open_text(data, "container-image-list.txt") as container_list_file:
+            containers_in_scope = container_list_file.read().splitlines()
+
+    if opts.o.verbose:
+        print(f'Containers: {containers_in_scope}')
+        if stack:
+            print(f"Stack: {stack}")
+
+    return containers_in_scope

stack_orchestrator/build/build_webapp.py

@@ -0,0 +1,117 @@
+# Copyright © 2022, 2023 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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/>.
+
+# Builds webapp containers
+
+# env vars:
+# CERC_REPO_BASE_DIR defaults to ~/cerc
+
+# TODO: display the available list of containers; allow re-build of either all or specific containers
+
+import os
+import sys
+
+from decouple import config
+import click
+from pathlib import Path
+from stack_orchestrator.build import build_containers
+from stack_orchestrator.deploy.webapp.util import determine_base_container, TimedLogger
+from stack_orchestrator.build.build_types import BuildContext
+
+
+@click.command()
+@click.option('--base-container')
+@click.option('--source-repo', help="directory containing the webapp to build", required=True)
+@click.option("--force-rebuild", is_flag=True, default=False, help="Override dependency checking -- always rebuild")
+@click.option("--extra-build-args", help="Supply extra arguments to build")
+@click.option("--tag", help="Container tag (default: cerc/<app_name>:local)")
+@click.pass_context
+def command(ctx, base_container, source_repo, force_rebuild, extra_build_args, tag):
+    '''build the specified webapp container'''
+    logger = TimedLogger()
+
+    quiet = ctx.obj.quiet
+    debug = ctx.obj.debug
+    verbose = ctx.obj.verbose
+    local_stack = ctx.obj.local_stack
+    stack = ctx.obj.stack
+
+    # See: https://stackoverflow.com/questions/25389095/python-get-path-of-root-project-structure
+    container_build_dir = Path(__file__).absolute().parent.parent.joinpath("data", "container-build")
+
+    if local_stack:
+        dev_root_path = os.getcwd()[0:os.getcwd().rindex("stack-orchestrator")]
+        logger.log(f'Local stack dev_root_path (CERC_REPO_BASE_DIR) overridden to: {dev_root_path}')
+    else:
+        dev_root_path = os.path.expanduser(config("CERC_REPO_BASE_DIR", default="~/cerc"))
+
+    if verbose:
+        logger.log(f'Dev Root is: {dev_root_path}')
+
+    if not base_container:
+        base_container = determine_base_container(source_repo)
+
+    # First build the base container.
+    container_build_env = build_containers.make_container_build_env(dev_root_path, container_build_dir, debug,
+                                                                    force_rebuild, extra_build_args)
+
+    if verbose:
+        logger.log(f"Building base container: {base_container}")
+
+    build_context_1 = BuildContext(
+        stack,
+        base_container,
+        container_build_dir,
+        container_build_env,
+        dev_root_path,
+    )
+    ok = build_containers.process_container(build_context_1)
+    if not ok:
+        logger.log("ERROR: Build failed.")
+        sys.exit(1)
+
+    if verbose:
+        logger.log(f"Base container {base_container} build finished.")
+
+    # Now build the target webapp.  We use the same build script, but with a different Dockerfile and work dir.
+    container_build_env["CERC_WEBAPP_BUILD_RUNNING"] = "true"
+    container_build_env["CERC_CONTAINER_BUILD_WORK_DIR"] = os.path.abspath(source_repo)
+    container_build_env["CERC_CONTAINER_BUILD_DOCKERFILE"] = os.path.join(container_build_dir,
+                                                                          base_container.replace("/", "-"),
+                                                                          "Dockerfile.webapp")
+    if not tag:
+        webapp_name = os.path.abspath(source_repo).split(os.path.sep)[-1]
+        tag = f"cerc/{webapp_name}:local"
+
+    container_build_env["CERC_CONTAINER_BUILD_TAG"] = tag
+
+    if verbose:
+        logger.log(f"Building app container: {tag}")
+
+    build_context_2 = BuildContext(
+        stack,
+        base_container,
+        container_build_dir,
+        container_build_env,
+        dev_root_path,
+    )
+    ok = build_containers.process_container(build_context_2)
+    if not ok:
+        logger.log("ERROR: Build failed.")
+        sys.exit(1)
+
+    if verbose:
+        logger.log(f"App container {base_container} build finished.")
+        logger.log("build-webapp complete", show_step_time=False, show_total_time=True)

stack_orchestrator/build/fetch_containers.py

@@ -0,0 +1,195 @@
+# Copyright © 2024 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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/>.
+
+import click
+from dataclasses import dataclass
+import json
+import platform
+from python_on_whales import DockerClient
+from python_on_whales.components.manifest.cli_wrapper import ManifestCLI, ManifestList
+from python_on_whales.utils import run
+import requests
+from typing import List
+
+from stack_orchestrator.opts import opts
+from stack_orchestrator.util import include_exclude_check, error_exit
+from stack_orchestrator.build.build_util import get_containers_in_scope
+
+# Experimental fetch-container command
+
+
+@dataclass
+class RegistryInfo:
+    registry: str
+    registry_username: str
+    registry_token: str
+
+
+# Extending this code to support the --verbose option, cnosider contributing upstream
+# https://github.com/gabrieldemarmiesse/python-on-whales/blob/master/python_on_whales/components/manifest/cli_wrapper.py#L129
+class ExtendedManifestCLI(ManifestCLI):
+    def inspect_verbose(self, x: str) -> ManifestList:
+        """Returns a Docker manifest list object."""
+        json_str = run(self.docker_cmd + ["manifest", "inspect", "--verbose", x])
+        return json.loads(json_str)
+
+
+def _local_tag_for(container: str):
+    return f"{container}:local"
+
+
+# See: https://docker-docs.uclv.cu/registry/spec/api/
+# Emulate this:
+# $ curl -u "my-username:my-token" -X GET "https://<container-registry-hostname>/v2/cerc-io/cerc/test-container/tags/list"
+# {"name":"cerc-io/cerc/test-container","tags":["202402232130","202402232208"]}
+def _get_tags_for_container(container: str, registry_info: RegistryInfo) -> List[str]:
+    # registry looks like: git.vdb.to/cerc-io
+    registry_parts = registry_info.registry.split("/")
+    url = f"https://{registry_parts[0]}/v2/{registry_parts[1]}/{container}/tags/list"
+    if opts.o.debug:
+        print(f"Fetching tags from: {url}")
+    response = requests.get(url, auth=(registry_info.registry_username, registry_info.registry_token))
+    if response.status_code == 200:
+        tag_info = response.json()
+        if opts.o.debug:
+            print(f"container tags list: {tag_info}")
+        tags_array = tag_info["tags"]
+        return tags_array
+    else:
+        error_exit(f"failed to fetch tags from image registry, status code: {response.status_code}")
+
+
+def _find_latest(candidate_tags: List[str]):
+    # Lex sort should give us the latest first
+    sorted_candidates = sorted(candidate_tags)
+    if opts.o.debug:
+        print(f"sorted candidates: {sorted_candidates}")
+    return sorted_candidates[-1]
+
+
+def _filter_for_platform(container: str, 
+                         registry_info: RegistryInfo,
+                         tag_list: List[str]) -> List[str] :
+    filtered_tags = []
+    this_machine = platform.machine()
+    # Translate between Python and docker platform names
+    if this_machine == "x86_64":
+        this_machine = "amd64"
+    if this_machine == "aarch64":
+        this_machine = "arm64"
+    if opts.o.debug:
+        print(f"Python says the architecture is: {this_machine}")
+    docker = DockerClient()
+    for tag in tag_list:
+        remote_tag = f"{registry_info.registry}/{container}:{tag}"
+        manifest_cmd = ExtendedManifestCLI(docker.client_config)
+        manifest = manifest_cmd.inspect_verbose(remote_tag)
+        if opts.o.debug:
+            print(f"manifest: {manifest}")
+        image_architecture =  manifest["Descriptor"]["platform"]["architecture"]
+        if opts.o.debug:
+            print(f"image_architecture: {image_architecture}")
+        if this_machine == image_architecture:
+            filtered_tags.append(tag)
+    if opts.o.debug:
+        print(f"Tags filtered for platform: {filtered_tags}")
+    return filtered_tags
+
+
+def _get_latest_image(container: str, registry_info: RegistryInfo):
+    all_tags = _get_tags_for_container(container, registry_info)
+    tags_for_platform = _filter_for_platform(container, registry_info, all_tags)
+    if len(tags_for_platform) > 0:
+        latest_tag = _find_latest(tags_for_platform)
+        return f"{container}:{latest_tag}"
+    else:
+        return None
+
+
+def _fetch_image(tag: str, registry_info: RegistryInfo):
+    docker = DockerClient()
+    remote_tag = f"{registry_info.registry}/{tag}"
+    if opts.o.debug:
+        print(f"Attempting to pull this image: {remote_tag}")
+    docker.image.pull(remote_tag)
+
+
+def _exists_locally(container: str):
+    docker = DockerClient()
+    return docker.image.exists(_local_tag_for(container))
+
+
+def _add_local_tag(remote_tag: str, registry: str, local_tag: str):
+    docker = DockerClient()
+    docker.image.tag(f"{registry}/{remote_tag}", local_tag)
+
+
+@click.command()
+@click.option('--include', help="only fetch these containers")
+@click.option('--exclude', help="don\'t fetch these containers")
+@click.option("--force-local-overwrite", is_flag=True, default=False, help="Overwrite a locally built image, if present")
+@click.option("--image-registry", required=True, help="Specify the image registry to fetch from")
+@click.option("--registry-username", required=True, help="Specify the image registry username")
+@click.option("--registry-token", required=True, help="Specify the image registry access token")
+@click.pass_context
+def command(ctx, include, exclude, force_local_overwrite, image_registry, registry_username, registry_token):
+    '''EXPERIMENTAL: fetch the images for a stack from remote registry'''
+
+    registry_info = RegistryInfo(image_registry, registry_username, registry_token)
+    docker = DockerClient()
+    if not opts.o.quiet:
+        print("Logging into container registry:")
+    docker.login(registry_info.registry, registry_info.registry_username, registry_info.registry_token)
+    # Generate list of target containers
+    stack = ctx.obj.stack
+    containers_in_scope = get_containers_in_scope(stack)
+    all_containers_found = True
+    for container in containers_in_scope:
+        local_tag = _local_tag_for(container)
+        if include_exclude_check(container, include, exclude):
+            if opts.o.debug:
+                print(f"Processing: {container}")
+            # For each container, attempt to find the latest of a set of
+            # images with the correct name and platform in the specified registry
+            image_to_fetch = _get_latest_image(container, registry_info)
+            if not image_to_fetch:
+                print(f"Warning: no image found to fetch for container: {container}")
+                all_containers_found = False
+                continue
+            if opts.o.debug:
+                print(f"Fetching: {image_to_fetch}")
+            _fetch_image(image_to_fetch, registry_info)
+            # Now check if the target container already exists exists locally already
+            if (_exists_locally(container)):
+                if not opts.o.quiet:
+                    print(f"Container image {container} already exists locally")
+                # if so, fail unless the user specified force-local-overwrite
+                if (force_local_overwrite):
+                    # In that case remove the existing :local tag
+                    if not opts.o.quiet:
+                        print(f"Warning: overwriting local tag from this image: {container} because "
+                              "--force-local-overwrite was specified")
+                else:
+                    if not opts.o.quiet:
+                        print(f"Skipping local tagging for this image: {container} because that would "
+                              "overwrite an existing :local tagged image, use --force-local-overwrite to do so.")
+                    continue
+            # Tag the fetched image with the :local tag
+            _add_local_tag(image_to_fetch, image_registry, local_tag)
+        else:
+            if opts.o.verbose:
+                print(f"Excluding: {container}")
+    if not all_containers_found:
+        print("Warning: couldn't find usable images for one or more containers, this stack will not deploy")

stack_orchestrator/build/publish.py

@@ -0,0 +1,48 @@
+# Copyright © 2024 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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 datetime import datetime
+from python_on_whales import DockerClient
+
+from stack_orchestrator.opts import opts
+from stack_orchestrator.util import error_exit
+
+
+def _publish_tag_for_image(local_image_tag: str, remote_repo: str, version: str):
+    # Turns image tags of the form: foo/bar:local into remote.repo/org/bar:deploy
+    (image_name, image_version) = local_image_tag.split(":")
+    if image_version == "local":
+        return f"{remote_repo}/{image_name}:{version}"
+    else:
+        error_exit("Asked to publish a non-locally built image")
+
+
+def publish_image(local_tag, registry):
+    if opts.o.verbose:
+        print(f"Publishing this image: {local_tag} to this registry: {registry}")
+    docker = DockerClient()
+    # Figure out the target image tag
+    # Eventually this version will be generated from the source repo state
+    # Using a timestemp is an intermediate step
+    version = datetime.now().strftime("%Y%m%d%H%M")
+    remote_tag = _publish_tag_for_image(local_tag, registry, version)
+    # Tag the image thus
+    if opts.o.debug:
+        print(f"Tagging {local_tag} to {remote_tag}")
+    docker.image.tag(local_tag, remote_tag)
+    # Push it to the desired registry
+    if opts.o.verbose:
+        print(f"Pushing image {remote_tag}")
+    docker.image.push(remote_tag)

stack_orchestrator/constants.py

@@ -0,0 +1,41 @@
+# Copyright © 2023 Vulcanize
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# 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/>.
+
+cluster_name_prefix = "laconic-"
+stack_file_name = "stack.yml"
+spec_file_name = "spec.yml"
+config_file_name = "config.env"
+deployment_file_name = "deployment.yml"
+compose_dir_name = "compose"
+compose_deploy_type = "compose"
+k8s_kind_deploy_type = "k8s-kind"
+k8s_deploy_type = "k8s"
+cluster_id_key = "cluster-id"
+kube_config_key = "kube-config"
+deploy_to_key = "deploy-to"
+network_key = "network"
+http_proxy_key = "http-proxy"
+image_registry_key = "image-registry"
+configmaps_key = "configmaps"
+resources_key = "resources"
+volumes_key = "volumes"
+security_key = "security"
+annotations_key = "annotations"
+labels_key = "labels"
+replicas_key = "replicas"
+node_affinities_key = "node-affinities"
+node_tolerations_key = "node-tolerations"
+kind_config_filename = "kind-config.yml"
+kube_config_filename = "kubeconfig.yml"

stack_orchestrator/data/compose/docker-compose-container-registry.yml

@@ -0,0 +1,15 @@
+services:
+  registry:
+    image: registry:2.8
+    restart: always
+    environment:
+      REGISTRY_LOG_LEVEL: ${REGISTRY_LOG_LEVEL}
+    volumes:
+      - config:/config:ro
+      - registry-data:/var/lib/registry
+    ports:
+      - "5000"
+
+volumes:
+  config:
+  registry-data:

stack_orchestrator/data/compose/docker-compose-fixturenet-blast.yml

@@ -0,0 +1,80 @@
+
+# From: https://raw.githubusercontent.com/blast-io/deployment/master/docker-compose.yml
+services:
+  # generate jwt.txt if it's absent
+  generate-jwt:
+    image: blastio/openssl
+    volumes:
+      - blast-data:/blast:rw
+    command: >
+      sh -c "[ ! -f /blast/jwt.txt ] && openssl rand -hex 32 | tr -d '\n' > /blast/jwt.txt || exit 0"
+  # initialise geth db
+  geth-init:
+    image: blastio/blast-geth:${NETWORK:-testnet-sepolia}
+    volumes:
+      - blast-data:/blast:rw
+      - ../config/fixturenet-blast/genesis.json:/blast/genesis.json
+    entrypoint: /bin/sh
+    command: >
+      -c "[ ! -d /blast/${GETH_DATA_DIR:-blast-geth-data}/geth ] && /usr/local/bin/geth init --datadir=/blast/${GETH_DATA_DIR:-blast-geth-data} /blast/genesis.json || exit 0"
+    depends_on:
+      generate-jwt:
+        condition: service_completed_successfully
+    env_file: 
+      - ../config/fixturenet-blast/${NETWORK:-fixturenet}.config
+  blast-geth:
+    image: blastio/blast-geth:${NETWORK:-testnet-sepolia}
+    volumes:
+      - blast-data:/blast
+    ports:
+      - "9545"
+      - "9546"
+    command: >
+      --datadir=/blast/${GETH_DATA_DIR:-blast-geth-data}
+      --http
+      --http.corsdomain="*"
+      --http.vhosts="*"
+      --http.addr=0.0.0.0
+      --http.port=9545
+      --http.api=web3,debug,eth,txpool,net,engine
+      --ws
+      --ws.addr=0.0.0.0
+      --ws.port=9546
+      --ws.origins="*"
+      --ws.api=debug,eth,txpool,net,engine
+      --authrpc.addr="0.0.0.0"
+      --authrpc.port="8551"
+      --authrpc.vhosts="*"
+      --authrpc.jwtsecret=/blast/jwt.txt
+      --syncmode=full
+      --gcmode=archive
+      --nodiscover
+      --maxpeers=0
+      --rollup.disabletxpoolgossip=true
+    env_file: 
+      - ../config/fixturenet-blast/${NETWORK:-fixturenet}.config
+    depends_on:
+      geth-init:
+        condition: service_completed_successfully
+  op-node:
+    image: blastio/blast-optimism:${NETWORK:-testnet-sepolia}
+    volumes:
+      - blast-data:/blast
+      - ../config/fixturenet-blast/rollup.json:/blast/rollup.json
+    ports:
+      - "9003"
+    command: >
+      op-node
+      --l1="${CERC_L1_RPC}"
+      --l1.rpckind="any"
+      --l1.trustrpc=true
+      --l2="http://blast-geth:8551"
+      --l2.jwt-secret=/blast/jwt.txt
+      --rollup.config="/blast/rollup.json"
+    depends_on:
+      - blast-geth
+    env_file: 
+      - ../config/fixturenet-blast/${NETWORK:-fixturenet}.config
+
+volumes:
+  blast-data: