testing blast update ecotone - add overrides and l2 beacon to compose, add RPC variables

Merge branch 'main' into blast-stack
linted
2024-05-24 22:57:53 +00:00 · 2024-04-08 15:21:03 +00:00 · 2024-04-08 15:17:44 +00:00 · 2024-04-05 09:26:08 +00:00 · 2024-04-05 08:27:46 +00:00 · 2024-04-04 10:50:02 +00:00
743 changed files with 102383 additions and 2278 deletions
@@ -0,0 +1,61 @@
 name: Fixturenet-Eth-Plugeth-Arm-Test
 on:
  push:
    branches: '*'
    paths:
      - '!**'
      - '.gitea/workflows/triggers/fixturenet-eth-plugeth-arm-test'
  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
    - cron: '2 14 * * *'
 # 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-arm
    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
      - 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-eth tests"
        run: ./tests/fixturenet-eth-plugeth/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 }}
@@ -0,0 +1,65 @@
 name: Fixturenet-Eth-Plugeth-Test
 on:
  push:
    branches: '*'
    paths:
      - '!**'
      - '.gitea/workflows/triggers/fixturenet-eth-plugeth-test'
  schedule: # Note: coordinate with other tests to not overload runners at the same time of day
    - cron: '2 14 * * *'
 # 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
      # At present the stock setup-python action fails on Linux/aarch64
      # Conditional steps below workaroud this by using deadsnakes for that case only
      - name: "Install Python for ARM on Linux"
        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
        uses: deadsnakes/action@v3.0.1
        with:
          python-version: '3.8'
      - name: "Install Python cases other than ARM on Linux"
        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
        uses: actions/setup-python@v4
        with:
          python-version: '3.8'
      - name: "Print Python version"
        run: python3 --version
      - name: "Install shiv"
        run: pip install shiv
      - name: "Generate build version file"
        run: ./scripts/create_build_tag_file.sh
      - name: "Build local shiv package"
        run: ./scripts/build_shiv_package.sh
      - name: Start dockerd # Also needed until we can incorporate into the executor
        run: |
          dockerd -H $DOCKER_HOST --userland-proxy=false &
          sleep 5
      - name: "Run fixturenet-eth tests"
        run: ./tests/fixturenet-eth-plugeth/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 }}
@@ -0,0 +1,63 @@
 name: Fixturenet-Eth-Test
 on:
  push:
    branches: '*'
    paths:
      - '!**'
      - '.gitea/workflows/triggers/fixturenet-eth-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 fixturenet test"
    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
      - 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/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 }}
@@ -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
      - 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 }}
@@ -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 }}
@@ -0,0 +1,72 @@
 name: Publish
 on:
  push:
    branches:
      - main
      - publish-test
    paths-ignore:
      - '.gitea/workflows/triggers/*'
 jobs:
  publish:
    name: "Build and publish"
    runs-on: ubuntu-latest
    steps:
      - name: "Clone project repository"
        uses: actions/checkout@v3
      - name: "Get build info"
        id: build-info
        run: |
          build_tag=$(./scripts/create_build_tag_file.sh)
          echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
      # At present the stock setup-python action fails on Linux/aarch64
      # Conditional steps below workaroud this by using deadsnakes for that case only
      - name: "Install Python for ARM on Linux"
        if: ${{ runner.arch == 'arm64' && runner.os == 'Linux' }}
        uses: deadsnakes/action@v3.0.1
        with:
          python-version: '3.8'
      - name: "Install Python cases other than ARM on Linux"
        if: ${{ ! (runner.arch == 'arm64' && runner.os == 'Linux') }}
        uses: actions/setup-python@v4
        with:
          python-version: '3.8'
      - name: "Print Python version"
        run: python3 --version
      - name: "Install shiv"
        run: pip install shiv
      - name: "Build local shiv package"
        id: build
        run: |
          ./scripts/build_shiv_package.sh
          result_code=$?
          echo "package-file=$(ls ./package/*)" >> $GITHUB_OUTPUT
          exit $result_code
      - name: "Stage artifact file"
        run: |
          cp ${{ steps.build.outputs.package-file }} ./laconic-so
      - name: "Create release"
        uses: https://gitea.com/cerc-io/action-gh-release@gitea-v2
        with:
          tag_name: ${{ steps.build-info.outputs.build-tag }}
          # On the publish test branch, mark our release as a draft
          # 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 }}
@@ -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
      - 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 }}
@@ -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
      - 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 }}
@@ -0,0 +1,65 @@
 name: Deploy Test
 on:
  pull_request:
    branches: '*'
  push:
    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:
    name: "Run deploy 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
      - 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 }}
@@ -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
      - 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 }}
@@ -0,0 +1,67 @@
 name: Webapp Test
 on:
  pull_request:
    branches: '*'
  push:
    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:
    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
      - 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: Start dockerd # Also needed until we can incorporate into the executor
        run: |
          dockerd -H $DOCKER_HOST --userland-proxy=false &
          sleep 5
      - 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 }}
@@ -0,0 +1,65 @@
 name: Smoke Test
 on:
  pull_request:
    branches: '*'
  push:
    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:
    name: "Run basic 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
      - 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 }}
@@ -0,0 +1,2 @@
 Change this file to trigger running the fixturenet-eth-plugeth-arm-test CI job
@@ -0,0 +1,3 @@
 Change this file to trigger running the fixturenet-eth-plugeth-test CI job
 trigger
 trigger
@@ -0,0 +1,2 @@
 Change this file to trigger running the fixturenet-eth-test CI job
@@ -0,0 +1,6 @@
 Change this file to trigger running the fixturenet-laconicd-test CI job
 Trigger
 Trigger
 Trigger
 Trigger
 Trigger
@@ -0,0 +1 @@
 Change this file to trigger running the test-container-registry CI job
@@ -0,0 +1,2 @@
 Change this file to trigger running the test-database CI job
 Trigger test run
@@ -0,0 +1,2 @@
 Change this file to trigger running the test-k8s-deploy CI job
 Trigger test on PR branch
@@ -0,0 +1,30 @@
 name: Fixturenet-Eth Test
 on:
  push:
    branches: '*'
    paths:
      - '!**'
      - '.github/workflows/triggers/fixturenet-eth-test'
 jobs:
  test:
    name: "Run fixturenet-eth 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-eth tests"
        run: ./tests/fixturenet-eth/run-test.sh
@@ -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
@@ -0,0 +1,21 @@
 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
@@ -0,0 +1,46 @@
 name: Publish
 on:
  push:
    branches:
      - main
      - publish-test
 jobs:
  publish:
    name: "Build and publish"
    runs-on: ubuntu-latest
    steps:
      - name: "Clone project repository"
        uses: actions/checkout@v3
      - name: "Get build info"
        id: build-info
        run: |
          build_tag=$(./scripts/create_build_tag_file.sh)
          echo "build-tag=v${build_tag}" >> $GITHUB_OUTPUT
      - 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: "Build local shiv package"
        id: build
        run: |
          ./scripts/build_shiv_package.sh
          result_code=$?
          echo "package-file=$(ls ./package/*)" >> $GITHUB_OUTPUT
          exit $result_code
      - name: "Stage artifact file"
        run: |
          cp ${{ steps.build.outputs.package-file }} ./laconic-so
      - name: "Create release"
        uses: softprops/action-gh-release@v1
        with:
          tag_name: ${{ steps.build-info.outputs.build-tag }}
          # On the publish test branch, mark our release as a draft
          # Hack using endsWith to workaround Gitea sometimes sending "publish-test" vs "refs/heads/publish-test"
          draft: ${{ endsWith('publish-test', github.ref ) }}
          files: ./laconic-so
@@ -0,0 +1,29 @@
 name: Deploy Test
 on:
  pull_request:
    branches: '*'
  push:
    branches: '*'
 jobs:
  test:
    name: "Run deploy 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 deploy tests"
        run: ./tests/deploy/run-deploy-test.sh
@@ -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
@@ -0,0 +1,29 @@
 name: Smoke Test
 on:
  pull_request:
    branches: '*'
  push:
    branches: '*'
 jobs:
  test:
    name: "Run basic 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 smoke tests"
        run: ./tests/smoke-test/run-smoke-test.sh
@@ -0,0 +1,2 @@
 Change this file to trigger running the fixturenet-eth-test CI job
@@ -0,0 +1,3 @@
 Change this file to trigger running the fixturenet-laconicd-test CI job
 trigger
@@ -5,4 +5,6 @@ laconic-so
 laconic_stack_orchestrator.egg-info
 __pycache__
 *~
-
+package
 stack_orchestrator/data/build_tag.txt
 /build
@@ -1,214 +1,82 @@
 # Stack Orchestrator
-Stack Orchestrator allows building and deployment of a Laconic stack on a single machine with minimial prerequisites.
+Stack Orchestrator allows building and deployment of a Laconic Stack on a single machine with minimial prerequisites. It is a Python3 CLI tool that runs on any OS with Python3 and Docker. The following diagram summarizes the relevant repositories in the Laconic Stack - and the relationship to Stack Orchestrator.
 ![The Stack](/docs/images/laconic-stack.png)
 ## Install
 **To get started quickly** on a fresh Ubuntu instance (e.g, Digital Ocean); [try this script](./scripts/quick-install-linux.sh). **WARNING:** always review scripts prior to running them so that you know what is happening on your machine.
 For any other installation, follow along below and **adapt these instructions based on the specifics of your system.**
 ## Setup
 ### User Mode
 User mode runs the orchestrator from a "binary" single-file release and does not require special Python environment setup. Use this mode unless you plan to make changes to the orchestrator source code.
 #### Prerequisites
 Stack Orchestrator is a Python3 CLI tool that runs on any OS with Python3 and Docker. Tested on: Ubuntu 20/22.
 Ensure that the following are already installed:
-1. Python3 (the stock Python3 version available in Ubuntu 20 and 22 is suitable)
+- [Python3](https://wiki.python.org/moin/BeginnersGuide/Download): `python3 --version` >= `3.8.10` (the Python3 shipped in Ubuntu 20+ is good to go)
-   ```
+- [Docker](https://docs.docker.com/get-docker/): `docker --version` >= `20.10.21`
-   $ python3 --version
+- [jq](https://stedolan.github.io/jq/download/): `jq --version` >= `1.5`
-   Python 3.8.10
+- [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git): `git --version` >= `2.10.3`
   ```
 2. Docker (Install a current version from dockerco, don't use the version from any Linux distro)
   ```
   $ docker --version
   Docker version 20.10.17, build 100c701
   ```
 3. If installed from regular package repository (not Docker Desktop), BE AWARE that the compose plugin may need to be installed, as well.
   ```
   DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
   mkdir -p $DOCKER_CONFIG/cli-plugins
   curl -SL https://github.com/docker/compose/releases/download/v2.11.2/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose
   chmod +x ~/.docker/cli-plugins/docker-compose
   # see https://docs.docker.com/compose/install/linux/#install-the-plugin-manually for further details
   # or to install for all users.
   ```
 #### Install
 1. Download the latest release from [this page](https://github.com/cerc-io/stack-orchestrator/tags), into a suitable directory (e.g. `~/bin`):
   ```
   $ cd ~/bin
   $ curl https://github.com/cerc-io/stack-orchestrator/releases/download/v1.0.0-alpha/laconic-so
   ```
 1. Ensure `laconic-so` is on the `PATH`
 1. Verify operation:
   ```
   $ ~/bin/laconic-so --help
   Usage: python -m laconic-so [OPTIONS] COMMAND [ARGS]...
-     Laconic Stack Orchestrator
+Note: if installing docker-compose via package manager on Linux (as opposed to Docker Desktop), you must [install the plugin](https://docs.docker.com/compose/install/linux/#install-the-plugin-manually), e.g. :
-   Options:
+```bash
-     --quiet
+mkdir -p ~/.docker/cli-plugins
-     --verbose
+curl -SL https://github.com/docker/compose/releases/download/v2.11.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose
-     --dry-run
+chmod +x ~/.docker/cli-plugins/docker-compose
-     --local-stack
+```
     -h, --help     Show this message and exit.
-   Commands:
+Next decide on a directory where you would like to put the stack-orchestrator program. Typically this would be 
-     build-containers    build the set of containers required for a complete...
+a "user" binary directory such as `~/bin` or perhaps `/usr/local/laconic` or possibly just the current working directory.
     deploy-system       deploy a stack
     setup-repositories  git clone the set of repositories required to build...
   ```
 ### Developer mode
 Suitable for developers either modifying or debugging the orchestrator Python code:
 #### Prerequisites
 In addition to the binary install prerequisites listed above, the following are required:
 1. Python venv package
   This may or may not be already installed depending on the host OS and version. Check by running:
   ```
   $ python3 -m venv
   usage: venv [-h] [--system-site-packages] [--symlinks | --copies] [--clear] [--upgrade] [--without-pip] [--prompt PROMPT] ENV_DIR [ENV_DIR ...]
   venv: error: the following arguments are required: ENV_DIR
   ```
   If the venv package is missing you should see a message indicating how to install it, for example with:
   ```
   $ apt install python3.8-venv
   ```
 #### Install
 1. Clone this repository:
   ```
   $ git clone (https://github.com/cerc-io/stack-orchestrator.git
   ```
 4. Enter the project directory:
   ```
   $ cd stack-orchestrator
   ```
 5. Create and activate a venv:
   ```
   $ python3 -m venv venv
   $ source ./venv/bin/activate
   (venv) $
   ```
 6. Install the cli in edit mode:
   ```
   $ pip install --editable .
   ```
 7. Verify installation:
   ```
   (venv) $ laconic-so
   Usage: laconic-so [OPTIONS] COMMAND [ARGS]...
-    Laconic Stack Orchestrator
+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:
-   Options:
+```bash
-    --quiet
+curl -L -o ~/bin/laconic-so https://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
-    --verbose
+```
    --dry-run
    -h, --help  Show this message and exit.
-   Commands:
+Give it execute permissions:
    build-containers    build the set of containers required for a complete...
    deploy-system       deploy a stack
    setup-repositories  git clone the set of repositories required to build...
   ```
-#### Build a zipapp (single file distributable script)
+```bash
-Use shiv to build a single file Python executable zip archive of laconic-so:
+chmod +x ~/bin/laconic-so
-1. Install [shiv](https://github.com/linkedin/shiv):
+```
   ```
   $ (venv) pip install shiv
   $ (venv) pip install wheel
   ```
 1. Run shiv to create a zipapp file:
   ```
   $ (venv)  shiv -c laconic-so -o laconic-so .
   ```
   This creates a file `./laconic-so` that is executable outside of any venv, and on other machines and OSes and architectures, and requiring only the system Python3:
 1. Verify it works:
   ```
   $ cp stack-orchetrator/laconic-so ~/bin
   $ laconic-so
      Usage: python -m laconic-so [OPTIONS] COMMAND [ARGS]...
-      Laconic Stack Orchestrator
+Ensure `laconic-so` is on the [`PATH`](https://unix.stackexchange.com/a/26059)
-   Options:
+Verify operation (your version will probably be different, just check here that you see some version output and not an error):
      --quiet
      --verbose
      --dry-run
      -h, --help  Show this message and exit.
-   Commands:
+```
-      build-containers    build the set of containers required for a complete...
+laconic-so version
-      deploy-system       deploy a stack
+Version: 1.1.0-7a607c2-202304260513
-      setup-repositories  git clone the set of repositories required to build...
+```
-   ```
+Save the distribution url to `~/.laconic-so/config.yml`:
-### CI Mode
+```bash
-_write-me_
+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:
 ```bash
 laconic-so update
 ```
 ## Usage
 There are three sub-commands: `setup-repositories`, `build-containers` and `deploy-system` that are generally run in order:
-Note: $ laconic-so will run the version installed to ~/bin, while ./laconic-so can be invoked to run locally built 
+The various [stacks](/stack_orchestrator/data/stacks) each contain instructions for running different stacks based on your use case. For example:
 version in a checkout
 ### Setup Repositories
 Clones the set of git repositories necessary to build a system.
-Note: the use of `ssh-agent` is recommended in order to avoid entering your ssh key passphrase for each repository.
+- [self-hosted Gitea](/stack_orchestrator/data/stacks/build-support)
-```
+- [an Optimism Fixturenet](/stack_orchestrator/data/stacks/fixturenet-optimism)
-$ laconic-so --verbose setup-repositories #this will default to ~/cerc or CERC_REPO_BASE_DIR from an env file
+- [laconicd with console and CLI](stack_orchestrator/data/stacks/fixturenet-laconic-loaded)
-#$ ./laconic-so --verbose --local-stack setup-repositories #this will use cwd ../ as dev_root_path
+- [kubo (IPFS)](stack_orchestrator/data/stacks/kubo)
 ```
 ### Build Containers
 Builds the set of docker container images required to run a system. It takes around 10 minutes to build all the containers from cold.
 ```
 $ laconic-so --verbose build-containers #this will default to ~/cerc or CERC_REPO_BASE_DIR from an env file
 #$ ./laconic-so --verbose --local-stack build-containers #this will use cwd ../ as dev_root_path
-```
+## Contributing
 ### Deploy System
 Uses `docker compose` to deploy a system.
-Use `---include <list of components>` to deploy a subset of all containers:
+See the [CONTRIBUTING.md](/docs/CONTRIBUTING.md) for developer mode install.
 ```
 $ laconic-so --verbose deploy-system --include db-sharding,contract,ipld-eth-server,go-ethereum-foundry up
 ```
 ```
 $ laconic-so --verbose deploy-system --include db-sharding,contract,ipld-eth-server,go-ethereum-foundry down
 ```
 Note: deploy-system command interacts with most recently built container images.
 ## Platform Support
 Native aarm64 is _not_ currently supported. x64 emulation on ARM64 macos should work (not yet tested).
 ## Implementation
 The orchestrator's operation is driven by files shown below. `repository-list.txt` container the list of git repositories; `container-image-list.txt` contains
 the list of container image names, while `clister-list.txt` specifies the set of compose components (corresponding to individual docker-compose-xxx.yml files which may in turn specify more than one container).
 Files required to build each container image are stored under `./container-build/<container-name>`
 Files required at deploy-time are stored under `./config/<component-name>`
 ```
 ├── pod-list.txt
 ├── compose
 │   ├── docker-compose-contract.yml
 │   ├── docker-compose-db-sharding.yml
 │   ├── docker-compose-db.yml
 │   ├── docker-compose-eth-statediff-fill-service.yml
 │   ├── docker-compose-go-ethereum-foundry.yml
 │   ├── docker-compose-ipld-eth-beacon-db.yml
 │   ├── docker-compose-ipld-eth-beacon-indexer.yml
 │   ├── docker-compose-ipld-eth-server.yml
 │   ├── docker-compose-lighthouse.yml
 │   └── docker-compose-prometheus-grafana.yml
 ├── config
 │   └── ipld-eth-server
 ├── container-build
 │   ├── cerc-eth-statediff-fill-service
 │   ├── cerc-go-ethereum
 │   ├── cerc-go-ethereum-foundry
 │   ├── cerc-ipld-eth-beacon-db
 │   ├── cerc-ipld-eth-beacon-indexer
 │   ├── cerc-ipld-eth-db
 │   ├── cerc-ipld-eth-server
 │   ├── cerc-lighthouse
 │   └── cerc-test-contract
 ├── container-image-list.txt
 ├── repository-list.txt
 ```
-_write-more-of-me_
+Native aarm64 is _not_ currently supported. x64 emulation on ARM64 macos should work (not yet tested).
@@ -1,86 +0,0 @@
 # Copyright © 2022 Cerc
 # 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 .util import include_exclude_check
 # 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.pass_context
 def command(ctx, include, exclude):
    '''build the set of containers required for a complete stack'''
    quiet = ctx.obj.quiet
    verbose = ctx.obj.verbose
    dry_run = ctx.obj.dry_run
    local_stack = ctx.obj.local_stack
    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')
    with open("container-image-list.txt") as container_list_file:
        containers = container_list_file.read().splitlines()
    if verbose:
        print(f'Containers: {containers}')
    def process_container(container):
        if not quiet:
            print(f"Building: {container}")
        build_script_filename = os.path.join("container-build", container.replace("/", "-"), "build.sh")
        if verbose:
            print(f"Script: {build_script_filename}")
        if not os.path.exists(build_script_filename):
            print(f"Error, script: {build_script_filename} doesn't exist")
            sys.exit(1)
        if not dry_run:
            # We need to export CERC_REPO_BASE_DIR
            build_result = subprocess.run(build_script_filename, shell=True, env={'CERC_REPO_BASE_DIR': dev_root_path})
            # TODO: check result in build_result.returncode
            print(f"Result is: {build_result}")
        else:
            print("Skipped")
    for container in containers:
        if include_exclude_check(container, include, exclude):
            process_container(container)
        else:
            if verbose:
                print(f"Excluding: {container}")
@@ -1,98 +0,0 @@
 # Copyright © 2022 Cerc
 # 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/>.
 # Deploys the system components using docker-compose
 import hashlib
 import os
 import sys
 from python_on_whales import DockerClient
 import click
 from .util import include_exclude_check
@click.command()
@click.option("--include", help="only start these components")
@click.option("--exclude", help="don\'t start these components")
@click.option("--cluster", help="specify a non-default cluster name")
@click.argument('command', required=True)  # help: command: up|down|ps
@click.argument('services', nargs=-1)  # help: command: up|down|ps <service1> <service2>
@click.pass_context
 def command(ctx, include, exclude, cluster, command, services):
    '''deploy a stack'''
    # TODO: implement option exclusion and command value constraint lost with the move from argparse to click
    quiet = ctx.obj.quiet
    verbose = ctx.obj.verbose
    dry_run = ctx.obj.dry_run
    if cluster is None:
        # Create default unique, stable cluster name from confile file path
        # TODO: change this to the config file path
        path = os.path.realpath(sys.argv[0])
        hash = hashlib.md5(path.encode()).hexdigest()
        cluster = f"laconic-{hash}"
        if verbose:
            print(f"Using cluster name: {cluster}")
    with open("pod-list.txt") as pod_list_file:
        pods = pod_list_file.read().splitlines()
    if verbose:
        print(f'Pods: {pods}')
    # Construct a docker compose command suitable for our purpose
    compose_files = []
    for pod in pods:
        if include_exclude_check(pod, include, exclude):
            compose_file_name = os.path.join("compose", f"docker-compose-{pod}.yml")
            compose_files.append(compose_file_name)
        else:
            if not quiet:
                print(f"Excluding: {pod}")
    if verbose:
        print(f"files: {compose_files}")
    # See: https://gabrieldemarmiesse.github.io/python-on-whales/sub-commands/compose/
    docker = DockerClient(compose_files=compose_files, compose_project_name=cluster)
    services_list = list(services) or None 
    if not dry_run:
        if command == "up":
            if verbose:
                print(f"Running compose up for services: {services_list}")
            docker.compose.up(detach=True, services=services_list)
        elif command == "down":
            if verbose:
                print("Running compose down")
            docker.compose.down()
        elif command == "status":
            if verbose:
                print("Running compose ps")
            container_list = docker.compose.ps()
            if len(container_list) > 0:
                print("Running containers:")
                for container in container_list:
                    print(f"id: {container.id}, name: {container.name}")
            else:
                print("No containers running")
        elif command == "logs":
            if verbose:
                print("Running compose logs")
            docker.compose.logs()
@@ -1,154 +0,0 @@
 # Copyright © 2022 Cerc
 # 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/>.
 # env vars:
 # CERC_REPO_BASE_DIR defaults to ~/cerc
 import os
 import sys
 from decouple import config
 import git
 from tqdm import tqdm
 import click
 from .util import include_exclude_check
 class GitProgress(git.RemoteProgress):
    def __init__(self):
        super().__init__()
        self.pbar = tqdm(unit='B', ascii=True, unit_scale=True)
    def update(self, op_code, cur_count, max_count=None, message=''):
        self.pbar.total = max_count
        self.pbar.n = cur_count
        self.pbar.refresh()
 def is_git_repo(path):
    try:
        _ = git.Repo(path).git_dir
        return True
    except git.exc.InvalidGitRepositoryError:
        return False
 # TODO: find a place for this in the context of click
 # parser = argparse.ArgumentParser(
 #    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 clone these repositories")
@click.option("--exclude", help="don\'t clone these repositories")
@click.option('--check-only', is_flag=True, default=False)
@click.option('--pull', is_flag=True, default=False)
@click.option('--branches-file', help="checkout branches specified in this file")
@click.pass_context
 def command(ctx, include, exclude, check_only, pull, branches_file):
    '''git clone the set of repositories required to build the complete system from source'''
    quiet = ctx.obj.quiet
    verbose = ctx.obj.verbose
    dry_run = ctx.obj.dry_run
    branches = []
    if branches_file:
        if verbose:
            print(f"loading branches from: {branches_file}")
        with open(branches_file) as branches_file_open:
            branches = branches_file_open.read().splitlines()
        if verbose:
            print(f"Branches are: {branches}")
    local_stack = ctx.obj.local_stack
    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):
        if not quiet:
            print('Dev root directory doesn\'t exist, creating')
        os.makedirs(dev_root_path)
    with open("repository-list.txt") as repository_list_file:
        all_repos = repository_list_file.read().splitlines()
    if verbose:
        print(f'Repos: {all_repos}')
    repos = []
    for repo in all_repos:
        if include_exclude_check(repo, include, exclude):
            repos.append(repo)
        else:
            if not quiet:
                print(f"Excluding: {repo}")
    def process_repo(repo):
        full_github_repo_path = f'git@github.com:{repo}'
        repoName = repo.split("/")[-1]
        full_filesystem_repo_path = os.path.join(dev_root_path, repoName)
        is_present = os.path.isdir(full_filesystem_repo_path)
        if not quiet:
            present_text = f'already exists active branch: {git.Repo(full_filesystem_repo_path).active_branch}' if is_present \
                else 'Needs to be fetched'
            print(f'Checking: {full_filesystem_repo_path}: {present_text}')
        # Quick check that it's actually a repo
        if is_present:
            if not is_git_repo(full_filesystem_repo_path):
                print(f'Error: {full_filesystem_repo_path} does not contain a valid git repository')
                sys.exit(1)
            else:
                if pull:
                    if verbose:
                        print(f'Running git pull for {full_filesystem_repo_path}')
                    if not check_only:
                        git_repo = git.Repo(full_filesystem_repo_path)
                        origin = git_repo.remotes.origin
                        origin.pull(progress=None if quiet else GitProgress())
                    else:
                        print("(git pull skipped)")
        if not is_present:
            # Clone
            if verbose:
                print(f'Running git clone for {full_github_repo_path} into {full_filesystem_repo_path}')
            if not dry_run:
                git.Repo.clone_from(full_github_repo_path,
                                    full_filesystem_repo_path,
                                    progress=None if quiet else GitProgress())
            else:
                print("(git clone skipped)")
        # Checkout the requested branch, if one was specified
        if branches:
            # Find the current repo in the branches list
            for repo_branch in branches:
                repo_branch_tuple = repo_branch.split(" ")
                if repo_branch_tuple[0] == repo:
                    # checkout specified branch
                    branch_to_checkout = repo_branch_tuple[1]
                    if verbose:
                        print(f"checking out branch {branch_to_checkout} in repo {repo}")
                        git_repo = git.Repo(full_filesystem_repo_path)
                        git_repo.git.checkout(branch_to_checkout)
    for repo in repos:
        process_repo(repo)
@@ -1,47 +0,0 @@
 # Copyright © 2022 Cerc
 # 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 import setup_repositories
 from app import build_containers
 from app import deploy_system
 CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
 class Options(object):
    def __init__(self, quiet, verbose, dry_run, local_stack):
        self.quiet = quiet
        self.verbose = verbose
        self.dry_run = dry_run
        self.local_stack = local_stack
@click.group(context_settings=CONTEXT_SETTINGS)
@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)
 # See: https://click.palletsprojects.com/en/8.1.x/complex/#building-a-git-clone
@click.pass_context
 def cli(ctx, quiet, verbose, dry_run, local_stack):
    """Laconic Stack Orchestrator"""
    ctx.obj = Options(quiet, verbose, dry_run, local_stack)
 cli.add_command(setup_repositories.command, "setup-repositories")
 cli.add_command(build_containers.command, "build-containers")
 cli.add_command(deploy_system.command, "deploy-system")
@@ -1,21 +0,0 @@
 version: "3.2"
 services:
  laconicd:
    restart: unless-stopped
    image: cerc/laconicd:local
    command: ["sh", "/docker-entrypoint-scripts.d/create-fixturenet.sh"]
    volumes:
      # TODO: look at folding this script into the container
      - ../config/fixturenet-laconicd/create-fixturenet.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh
    # TODO: determine which of the ports below is really needed
    ports:
      - "6060"
      - "26657"
      - "26656"
      - "9473"
      - "8545"
      - "8546"
      - "9090"
      - "9091"
      - "1317"
@@ -1,33 +0,0 @@
 version: "3.2"
 services:
  ipld-eth-server:
    restart: unless-stopped
    depends_on:
      ipld-eth-db:
        condition: service_healthy
    image: cerc/ipld-eth-server:local
    environment:
      IPLD_SERVER_GRAPHQL: "true"
      IPLD_POSTGRAPHILEPATH: http://graphql:5000
      ETH_SERVER_HTTPPATH: 0.0.0.0:8081
      ETH_SERVER_GRAPHQL: "true"
      ETH_SERVER_GRAPHQLPATH: 0.0.0.0:8082
      VDB_COMMAND: "serve"
      ETH_CHAIN_CONFIG: "/tmp/chain.json"
      DATABASE_NAME: cerc_testing
      DATABASE_HOSTNAME: ipld-eth-db
      DATABASE_PORT: 5432
      DATABASE_USER: "vdbm"
      DATABASE_PASSWORD: "password"
      ETH_CHAIN_ID: 99
      ETH_FORWARD_ETH_CALLS: $eth_forward_eth_calls
      ETH_PROXY_ON_ERROR: $eth_proxy_on_error
      ETH_HTTP_PATH: $eth_http_path
    volumes:
      - type: bind
        source: ../config/ipld-eth-server/chain.json
        target: /tmp/chain.json
    ports:
      - "127.0.0.1:8081:8081"
      - "127.0.0.1:8082:8082"
@@ -1,21 +0,0 @@
 version: "3.2"
 services:
  # If you want prometheus to work, you must update the following file in the ops repo locally.
  # localhost:6060 --> go-ethereum:6060
  prometheus:
    restart: always
    user: "987"
    image: prom/prometheus
    volumes:
      - ${cerc_ops}/metrics/etc:/etc/prometheus
      - ./prometheus-data:/prometheus
    ports:
      - "127.0.0.1:9090:9090"
  grafana:
    restart: always
    user: "472"
    image: grafana/grafana
    volumes:
      - ./grafana-data:/var/lib/grafana
    ports:
      - "127.0.0.1:3000:3000"
@@ -1,5 +0,0 @@
 version: "3.2"
 services:
  test:
    image: cerc/test-container:local
    restart: always
@@ -1,118 +0,0 @@
 #!/bin/sh
 # Originally from: https://github.com/cerc-io/laconicd/blob/main/init.sh
 # TODO: fold this back into the laconicd repo
 KEY="mykey"
 CHAINID="laconic_9000-1"
 MONIKER="localtestnet"
 KEYRING="test"
 KEYALGO="eth_secp256k1"
 LOGLEVEL="info"
 # to 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 laconic (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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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_NAMESERVICE_EXPIRY" == "true" ]]; then
  echo "Setting timers for expiry tests."
  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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["nameservice"]["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
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/eth-statediff-fill-service
 docker build -t cerc/eth-statediff-fill-service:local ${CERC_REPO_BASE_DIR}/eth-statediff-fill-service
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/eth-statediff-service
 docker build -t cerc/eth-statediff-service:local ${CERC_REPO_BASE_DIR}/eth-statediff-service
@@ -1,19 +0,0 @@
 FROM skylenet/ethereum-genesis-generator@sha256:210353ce7c898686bc5092f16c61220a76d357f51eff9c451e9ad1b9ad03d4d3 AS ethgen
 FROM cerc/go-ethereum:local
 RUN apk add --no-cache python3 python3-dev py3-pip curl wget jq build-base gettext libintl openssl bash
 COPY --from=ethgen /usr/local/bin/eth2-testnet-genesis /usr/local/bin/eth2-testnet-genesis
 COPY --from=ethgen /usr/local/bin/eth2-val-tools /usr/local/bin/eth2-val-tools
 COPY --from=ethgen /apps /apps
 RUN cd /apps/el-gen && pip3 install -r requirements.txt
 COPY genesis /opt/testnet
 COPY run-el.sh /opt/testnet/run.sh
 RUN cd /opt/testnet && make genesis-el
 RUN geth init /opt/testnet/build/el/geth.json && rm -f ~/.ethereum/geth/nodekey
 ENTRYPOINT ["/opt/testnet/run.sh"]
@@ -1,15 +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 }'`
 python3 /apps/el-gen/genesis_geth.py $tmp_dir/genesis-config.yaml | jq ".config.terminalTotalDifficulty=$ttd" > ../build/el/geth.json
 python3 ../accounts/mnemonic_to_csv.py $tmp_dir/genesis-config.yaml > ../build/el/accounts.csv
@@ -1,53 +0,0 @@
 #!/bin/bash
 ETHERBASE=`cat /opt/testnet/build/el/accounts.csv | head -1 | cut -d',' -f2`
 NETWORK_ID=`cat /opt/testnet/el/el-config.yaml | grep 'chain_id' | awk '{ print $2 }'`
 NETRESTRICT=`ip addr | grep inet | grep -v '127.0' | awk '{print $2}'`
 if [ "true" == "$RUN_BOOTNODE" ]; then 
    geth \
      --nodekeyhex="b0ac22adcad37213c7c565810a50f1772291e7b0ce53fb73e7ec2a3c75bc13b5" \
      --nodiscover \
      --ipcdisable \
      --networkid=${NETWORK_ID} \
      --netrestrict="${NETRESTRICT}"  2>&1 | tee /var/log/geth_bootnode.log
 else
    cd /opt/testnet/accounts
    ./import_keys.sh
    echo -n "$JWT" > /opt/testnet/build/el/jwtsecret
    STATEDIFF_OPTS=""
    if [ "$CERC_RUN_STATEDIFF" == "true" ]; then
      STATEDIFF_OPTS="--statediff=true \
      --statediff.db.host=$CERC_STATEDIFF_DB_HOST \
      --statediff.db.name=$CERC_STATEDIFF_DB_NAME \
      --statediff.db.nodeid=$CERC_STATEDIFF_DB_NODE_ID \
      --statediff.db.password=$CERC_STATEDIFF_DB_PASSWORD \
      --statediff.db.port=$CERC_STATEDIFF_DB_PORT \
      --statediff.db.user=$CERC_STATEDIFF_DB_USER \
      --statediff.waitforsync=true \
      --statediff.writing=true"
    fi
    geth \
      --bootnodes="${ENODE}" \
      --allow-insecure-unlock \
      --http \
      --http.addr="0.0.0.0" \
      --http.vhosts="*" \
      --http.api="eth,web3,net,admin,personal" \
      --http.corsdomain="*" \
      --authrpc.addr="0.0.0.0" \
      --authrpc.vhosts="*" \
      --authrpc.jwtsecret="/opt/testnet/build/el/jwtsecret" \
      --networkid="${NETWORK_ID}" \
      --netrestrict="${NETRESTRICT}" \
      --gcmode archive \
      --txlookuplimit=0 \
      --cache.preimages \
      --syncmode=full \
      --mine \
      --miner.threads=1 \
      --miner.etherbase="${ETHERBASE}" ${STATEDIFF_OPTS} 2>&1 | tee /var/log/geth.log
 fi
@@ -1,37 +0,0 @@
 #!/usr/bin/env bash
 # See: https://github.com/sigp/lighthouse/blob/stable/scripts/local_testnet/bootnode.sh
 #
 # Starts a bootnode from the generated enr.
 #
 set -Eeuo pipefail
 source ./vars.env
 DEBUG_LEVEL=${1:-info}
 echo "Starting bootnode"
 if [ ! -f "$DATADIR/bootnode/enr.dat" ]; then
  echo "Generating bootnode enr"
  lcli \
    generate-bootnode-enr \
    --ip $ENR_IP \
    --udp-port $BOOTNODE_PORT \
    --tcp-port $BOOTNODE_PORT \
    --genesis-fork-version $GENESIS_FORK_VERSION \
    --output-dir $DATADIR/bootnode
    bootnode_enr=`cat $DATADIR/bootnode/enr.dat`
    echo "- $bootnode_enr" > $TESTNET_DIR/boot_enr.yaml
    echo "Generated bootnode enr and written to $TESTNET_DIR/boot_enr.yaml"
 fi
 exec lighthouse boot_node \
    --testnet-dir $TESTNET_DIR \
    --port $BOOTNODE_PORT \
    --listen-address 0.0.0.0 \
    --disable-packet-filter \
    --network-dir $DATADIR/bootnode \
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/go-ethereum
 docker build -t cerc/go-ethereum:local ${CERC_REPO_BASE_DIR}/go-ethereum
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/ipld-eth-beacon-db
 docker build -t cerc/ipld-eth-beacon-db:local ${CERC_REPO_BASE_DIR}/ipld-eth-beacon-db
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/ipld-eth-beacon-indexer
 docker build -t cerc/ipld-eth-beacon-indexer:local ${CERC_REPO_BASE_DIR}/ipld-eth-beacon-indexer
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/ipld-eth-db
 docker build -t cerc/ipld-eth-db:local ${CERC_REPO_BASE_DIR}/ipld-eth-db
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/ipld-eth-server
 docker build -t cerc/ipld-eth-server:local ${CERC_REPO_BASE_DIR}/ipld-eth-server
@@ -1,13 +0,0 @@
 # TODO: move this into the cerc-io/laconic-sdk (aka client) repo
 FROM node:16.17.1-alpine3.16
 ARG NPM_AUTH_TOKEN
 WORKDIR /app
 COPY . .
 RUN echo //npm.pkg.github.com/:_authToken=$NPM_AUTH_TOKEN > ~/.npmrc
 RUN apk --update --no-cache add git && yarn && yarn build
 ENTRYPOINT ["/app/bin/laconic"]
@@ -1,7 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/laconic-cns-cli
 # See: https://stackoverflow.com/a/246128/1701505
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 docker build -t cerc/laconic-cns-cli:local -f ${SCRIPT_DIR}/Dockerfile --build-arg NPM_AUTH_TOKEN=$(NPM_AUTH_TOKEN) ${CERC_REPO_BASE_DIR}/laconic-cns-cli
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/chiba-clonk
 docker build -t cerc/laconicd:local ${CERC_REPO_BASE_DIR}/laconicd
@@ -1,8 +0,0 @@
 FROM sigp/lighthouse:v3.2.1-modern
 RUN apt-get update; apt-get install bash netcat curl less jq -y;
 WORKDIR /root/
 ADD start-lighthouse.sh .
 ENTRYPOINT [ "./start-lighthouse.sh" ]
@@ -1,5 +0,0 @@
 FROM alpine:latest
 COPY run.sh /app/run.sh
 ENTRYPOINT ["/app/run.sh"]
@@ -1,16 +0,0 @@
 #!/bin/sh
 # Test if the container's filesystem is old (run previously) or new
 EXISTSFILENAME=/var/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
 # Sleep forever to keep docker happy
 while true; do sleep 10; done
@@ -1,3 +0,0 @@
 #!/usr/bin/env bash
 # Build cerc/test-contract
 docker build -t cerc/test-contract:local --build-arg ETH_ADDR=http://go-ethereum:8545 ${CERC_REPO_BASE_DIR}/ipld-eth-db-validator/test/contract
@@ -1,27 +0,0 @@
 # TODO: move this into the cerc-io/mobymask-watcher repo
 FROM node:16.17.1-alpine3.16
 RUN apk --update --no-cache add git python3 alpine-sdk
 WORKDIR /app
 COPY assemblyscript assemblyscript
 COPY watcher-ts watcher-ts
 # TODO: needs branch ng-integrate-asyncify
 # We use a mixture of npm and yarn below because the upstream
 # project checked in an npm package-log.json file
 RUN echo "Building assemblyscript" && \
    cd assemblyscript && \
    npm install && npm run build && yarn link
 # TODO: needs branch v0.2.13
 # The shenanigans below is due to yarn and lerna being a dumpster-fire
 RUN echo "Linking watcher-ts to local assemblyscript" && \
    cd watcher-ts/packages/graph-node && yarn remove @vulcanize/assemblyscript && \
    yarn add https://github.com/vulcanize/assemblyscript.git#ng-integrate-asyncify
 RUN echo "Building watcher-tst" && \
    cd watcher-ts && yarn && yarn link "@vulcanize/assemblyscript" && yarn build
 WORKDIR /app/watcher-ts/packages/mobymask-watcher
@@ -1,16 +0,0 @@
 cerc/test-contract
 cerc/eth-statediff-fill-service
 cerc/eth-statediff-service
 cerc/go-ethereum
 cerc/go-ethereum-foundry
 cerc/lighthouse
 cerc/ipld-eth-db
 cerc/ipld-eth-beacon-db
 cerc/ipld-eth-beacon-indexer
 cerc/ipld-eth-server
 cerc/laconicd
 cerc/laconic-cns-cli
 cerc/fixturenet-eth-geth
 cerc/fixturenet-eth-lighthouse
 cerc/watcher-mobymask
 cerc/test-container
@@ -0,0 +1,113 @@
 # Contributing
 Thank you for taking the time to make a contribution to Stack Orchestrator.
 ## Install (developer mode)
 Suitable for developers either modifying or debugging the orchestrator Python code:
 ### Prerequisites
 In addition to the pre-requisites listed in the [README](/README.md), the following are required:
 1. Python venv package
   This may or may not be already installed depending on the host OS and version. Check by running:
   ```
   $ python3 -m venv
   usage: venv [-h] [--system-site-packages] [--symlinks | --copies] [--clear] [--upgrade] [--without-pip] [--prompt PROMPT] ENV_DIR [ENV_DIR ...]
   venv: error: the following arguments are required: ENV_DIR
   ```
   If the venv package is missing you should see a message indicating how to install it, for example with:
   ```
   $ apt install python3.10-venv
   ```
 ### Install
 1. Clone this repository:
   ```
   $ git clone https://git.vdb.to/cerc-io/stack-orchestrator.git
   ```
 2. Enter the project directory:
   ```
   $ cd stack-orchestrator
   ```
 3. (This and the next step can be done by running `source ./scripts/developer-mode-setup.sh`)
   Create and activate a venv:
   ```
   $ python3 -m venv venv
   $ source ./venv/bin/activate
   (venv) $
   ```
 4. Install the cli in edit mode:
   ```
   $ pip install --editable .
   ```
 5. Verify installation:
   ```
   (venv) $ laconic-so
   Usage: laconic-so [OPTIONS] COMMAND [ARGS]...
    Laconic Stack Orchestrator
   Options:
    --quiet
    --verbose
    --dry-run
    -h, --help  Show this message and exit.
   Commands:
    build-containers    build the set of containers required for a complete...
    deploy-system       deploy a stack
    setup-repositories  git clone the set of repositories required to build...
   ```
 ## Build a zipapp (single file distributable script)
 Use shiv to build a single file Python executable zip archive of laconic-so:
 1. Install [shiv](https://github.com/linkedin/shiv):
   ```
   $ (venv) pip install shiv
   $ (venv) pip install wheel
   ```
 2. Run shiv to create a zipapp file:
   ```
   $ (venv)  shiv -c laconic-so -o laconic-so .
   ```
   This creates a file `./laconic-so` that is executable outside of any venv, and on other machines and OSes and architectures, and requiring only the system Python3:
 3. Verify it works:
   ```
   $ cp stack-orchetrator/laconic-so ~/bin
   $ laconic-so
      Usage: laconic-so [OPTIONS] COMMAND [ARGS]...
      Laconic Stack Orchestrator
   Options:
      --stack TEXT         specify a stack to build/deploy
      --quiet
      --verbose
      --dry-run
      --local-stack
      --debug
      --continue-on-error
      -h, --help           Show this message and exit.
   Commands:
      build-containers    build the set of containers required for a complete...
      build-npms          build the set of npm packages required for a...
      deploy              deploy a stack
      deploy-system       deploy a stack
      setup-repositories  git clone the set of repositories required to build...
      version             print tool version
   ```
 For cutting releases, use the [shiv build script](/scripts/build_shiv_package.sh).
@@ -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)
@@ -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
 ```
@@ -0,0 +1,67 @@
 # laconic-so
 Sub-commands and flags
 ## setup-repositories
 Clone a single repository:
 ```
 $ laconic-so setup-repositories --include github.com/cerc-io/go-ethereum
 ```
 Clone the repositories for a stack:
 ```
 $ laconic-so --stack fixturenet-eth setup-repositories
 ```
 Pull latest commits from origin:
 ```
 $ laconic-so --stack fixturenet-eth setup-repositories --pull
 ```
 Use SSH rather than https:
 ```
 $ laconic-so --stack fixturenet-eth setup-repositories --git-ssh
 ```
 ## build-containers
 Build a single container:
 ```
 $ laconic-so build-containers --include <container-name>
 ```
 e.g.
 ```
 $ laconic-so build-containers --include cerc/go-ethereum
 ```
 Build the containers for a stack:
 ```
 $ laconic-so --stack <stack-name> build-containers
 ```
 e.g.
 ```
 $ laconic-so --stack fixturenet-eth build-containers
 ```
 Force full rebuild of container images:
 ```
 $ laconic-so build-containers --include <container-name> --force-rebuild
 ```
 ## build-npms
 Build a single package:
 ```
 $ laconic-so build-npms --include <package-name>
 ```
 e.g.
 ```
 $ laconic-so build-npms --include laconic-sdk
 ```
 Build the packages for a stack:
 ```
 $ laconic-so --stack <stack-name> build-npms
 ```
 e.g.
 ```
 $ laconic-so --stack fixturenet-laconicd build-npms
 ```
 Force full rebuild of packages:
 ```
 $ laconic-so build-npms --include <package-name> --force-rebuild
 ```
@@ -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
 ```
@@ -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/laconic-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 cns status"
 ```
 Try additional CLI commands, documented [here](https://github.com/cerc-io/laconic-registry-cli#operations).
@@ -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 4 repositories had to be cloned and setup manually:
 - https://git.vdb.to/cerc-io/laconicd
 - https://git.vdb.to/cerc-io/laconic-sdk
 - 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,git.vdb.to/cerc-io/laconic-sdk,git.vdb.to/cerc-io/laconic-registry-cli,git.vdb.to/cerc-io/laconic-console
    ```
 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
    ```
    ```
    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:
    ```
    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
    ```
 4. Confirm operation of the registry CLI:
   ```
   laconic-so deployment --dir laconic-loaded-deployment 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
 (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 --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://git.vdb.to/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"
 ```
@@ -0,0 +1,29 @@
 # Release Process
 ## Manually publish to github releases
 In order to build, the shiv and wheel packages must be installed:
 ```
 $ pip install shiv
 $ pip install wheel
 ```
 Then:
 1. Define `CERC_GH_RELEASE_SCRIPTS_DIR`
 1. Define `CERC_PACKAGE_RELEASE_GITHUB_TOKEN`
 1. Run `./scripts/tag_new_release.sh <major> <minor> <patch>`
 1. Run `./scripts/build_shiv_package.sh`
 1. Run `./scripts/publish_shiv_package_github.sh <major> <minor> <patch>`
 1. Commit the new version file.
 e.g.
 ```
 $ export CERC_GH_RELEASE_SCRIPTS_DIR=~/projects/cerc/github-release-api/
 $ export CERC_PACKAGE_RELEASE_GITHUB_TOKEN=github_pat_xxxxxx
 $ ./scripts/tag_new_release.sh 1 0 17
 $ ./scripts/build_shiv_package.sh
 $ ./scripts/publish_shiv_package_github.sh 1 0 17
 ```
@@ -0,0 +1,83 @@
 # Specification
 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
 The orchestrator's operation is driven by files shown below. 
 - `repository-list.txt` contains the list of git repositories; 
 - `container-image-list.txt` contains the list of container image names
 - `pod-list.txt` specifies the set of compose components (corresponding to individual docker-compose-xxx.yml files which may in turn specify more than one container).
 - `container-build/` contains the files required to build each container image
 - `config/` contains the files required at deploy time
 ```
 ├── container-image-list.txt
 ├── pod-list.txt
 ├── repository-list.txt
 ├── compose
 │   ├── docker-compose-contract.yml
 │   ├── docker-compose-eth-probe.yml
 │   ├── docker-compose-eth-statediff-fill-service.yml
 │   ├── docker-compose-fixturenet-eth.yml
 │   ├── docker-compose-fixturenet-laconicd.yml
 │   ├── docker-compose-go-ethereum-foundry.yml
 │   ├── docker-compose-ipld-eth-beacon-db.yml
 │   ├── docker-compose-ipld-eth-beacon-indexer.yml
 │   ├── docker-compose-ipld-eth-db.yml
 │   ├── docker-compose-ipld-eth-server.yml
 │   ├── docker-compose-keycloak.yml
 │   ├── docker-compose-laconicd.yml
 │   ├── docker-compose-prometheus-grafana.yml
 │   ├── docker-compose-test.yml
 │   ├── docker-compose-tx-spammer.yml
 │   ├── docker-compose-watcher-erc20.yml
 │   ├── docker-compose-watcher-erc721.yml
 │   ├── docker-compose-watcher-mobymask.yml
 │   └── docker-compose-watcher-uniswap-v3.yml
 ├── config
 │   ├── fixturenet-eth
 │   ├── fixturenet-laconicd
 │   ├── ipld-eth-beacon-indexer
 │   ├── ipld-eth-server
 │   ├── keycloak
 │   ├── postgresql
 │   ├── tx-spammer
 │   ├── watcher-erc20
 │   ├── watcher-erc721
 │   ├── watcher-mobymask
 │   └── watcher-uniswap-v3
 ├── container-build
 │   ├── cerc-builder-js
 │   ├── cerc-eth-probe
 │   ├── cerc-eth-statediff-fill-service
 │   ├── cerc-eth-statediff-service
 │   ├── cerc-fixturenet-eth-geth
 │   ├── cerc-fixturenet-eth-lighthouse
 │   ├── cerc-go-ethereum
 │   ├── cerc-go-ethereum-foundry
 │   ├── cerc-ipld-eth-beacon-db
 │   ├── cerc-ipld-eth-beacon-indexer
 │   ├── cerc-ipld-eth-db
 │   ├── cerc-ipld-eth-server
 │   ├── cerc-keycloak
 │   ├── cerc-laconic-registry-cli
 │   ├── cerc-laconicd
 │   ├── cerc-lighthouse
 │   ├── cerc-test-container
 │   ├── cerc-test-contract
 │   ├── cerc-tx-spammer
 │   ├── cerc-uniswap-v3-info
 │   ├── cerc-watcher-erc20
 │   ├── cerc-watcher-erc721
 │   ├── cerc-watcher-mobymask
 │   ├── cerc-watcher-uniswap-v3
 └── stacks
    ├── erc20
    ├── erc721
    ├── fixturenet-eth
    ├── fixturenet-laconicd
    ├── mobymask
    └── uniswap-v3
 ```
@@ -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
 ```
@@ -1,8 +0,0 @@
 #!/bin/bash
 python3 -m venv venv
 source ./venv/bin/activate
 pip install --editable .
 pip install shiv
 shiv -c laconic-so -o laconic-so .
 ./laconic-so --verbose --local-stack setup-repositories
@@ -1,14 +0,0 @@
 contract
 db
 eth-statediff-fill-service
 go-ethereum-foundry
 ipld-eth-beacon-db
 ipld-eth-beacon-indexer
 ipld-eth-server
 lighthouse
 prometheus-grafana
 laconicd
 fixturenet-laconicd
 fixturenet-eth
 watcher-mobymask
 test
@@ -1,14 +0,0 @@
 vulcanize/ops
 cerc-io/ipld-eth-db
 cerc-io/go-ethereum
 cerc-io/ipld-eth-server
 cerc-io/eth-statediff-service
 vulcanize/eth-statediff-fill-service
 vulcanize/ipld-eth-db-validator
 vulcanize/ipld-eth-beacon-indexer
 vulcanize/ipld-eth-beacon-db
 cerc-io/laconicd
 cerc-io/laconic-cns-cli
 cerc-io/mobymask-watcher
 cerc-io/watcher-ts
 vulcanize/assemblyscript
@@ -1,5 +1,13 @@
-python-decouple>=3.6
+python-decouple>=3.8
-GitPython>=3.1.27
+python-dotenv==1.0.0
-tqdm>=4.64.0
+GitPython>=3.1.32
-python-on-whales>=0.52.0
+tqdm>=4.65.0
-click>=8.1.3
+python-on-whales>=0.64.0
 click>=8.1.6
 PyYAML>=6.0.1
 ruamel.yaml>=0.17.32
 pydantic==1.10.9
 tomli==2.0.1
 validators==0.22.0
 kubernetes>=28.1.0
 humanfriendly>=10.0
@@ -0,0 +1,4 @@
 # Builds the shiv "package" for distribution
 mkdir -p ./package
 version_string=$( ./scripts/create_build_tag_file.sh )
 shiv -c laconic-so -o package/laconic-so-${version_string} .
@@ -0,0 +1,44 @@
 #cloud-config
 # Used for easily testing stacks-in-development on cloud platforms
 # Assumes Ubuntu, edit the last line if targeting a different OS
 # Once SSH'd into the server, run:
 # `$ cd stack-orchestrator`
 # `$ git checkout <branch>
 # `$ ./scripts/developer-mode-setup.sh`
 # `$ source ./venv/bin/activate`
 # Followed by the stack instructions.
 package_update: true
 package_upgrade: true
 groups:
  - docker
 system_info:
  default_user:
    groups: [ docker ]
 packages:
  - apt-transport-https
  - ca-certificates
  - curl
  - jq
  - git
  - gnupg
  - lsb-release
  - unattended-upgrades
  - python3.10-venv
  - pip
 runcmd:
  - mkdir -p /etc/apt/keyrings
  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
  - echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
  - apt-get update
  - 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://git.vdb.to/cerc-io/stack-orchestrator.git /home/ubuntu/stack-orchestrator
@@ -0,0 +1,35 @@
 #cloud-config
 # Used for installing Stack Orchestrator on platforms that support `cloud-init`
 # Tested on Ubuntu
 package_update: true
 package_upgrade: true
 groups:
  - docker
 system_info:
  default_user:
    groups: [ docker ]
 packages:
  - apt-transport-https
  - ca-certificates
  - curl
  - jq
  - git
  - gnupg
  - lsb-release
  - unattended-upgrades
 runcmd:
  - mkdir -p /etc/apt/keyrings
  - curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
  - echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
  - apt-get update
  - 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://git.vdb.to/cerc-io/stack-orchestrator/releases/download/latest/laconic-so
  - chmod +x /usr/local/bin/laconic-so
@@ -0,0 +1,8 @@
 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 ./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}
 echo ${build_tag_string} >> $build_tag_file_name
 echo ${build_tag_string}
@@ -0,0 +1,12 @@
 #!/usr/bin/env bash
 # Script to automate the steps needed to make a cloned project repo runnable on the path
 # (beware of PATH having some other file with the same name ahead of ours)
 if [[ -n "$CERC_SCRIPT_DEBUG" ]]; then
    set -x
    echo PATH is $PATH
 fi
 python3 -m venv venv
 source ./venv/bin/activate
 python3 -m pip install --upgrade pip setuptools wheel
 pip install shiv
 pip install --editable .
@@ -0,0 +1,40 @@
 #!/usr/bin/env bash
 # Usage: publish_shiv_package_github.sh <major> <minor> <patch>
 # Uses this script package to publish a new release:
 # https://github.com/cerc-io/github-release-api
 # User must define: CERC_GH_RELEASE_SCRIPTS_DIR
 # pointing to the location of that cloned repository
 # e.g. 
 # cd ~/projects
 # git clone https://github.com/cerc-io/github-release-api
 # cd ./stack-orchestrator
 # export CERC_GH_RELEASE_SCRIPTS_DIR=~/projects/github-release-api
 # ./scripts/publish_shiv_package_github.sh
 # In addition, a valid GitHub token must be defined in
 # CERC_PACKAGE_RELEASE_GITHUB_TOKEN
 if [[ -z "${CERC_PACKAGE_RELEASE_GITHUB_TOKEN}" ]]; then
    echo "CERC_PACKAGE_RELEASE_GITHUB_TOKEN is not set" >&2
    exit 1
 fi
 # TODO: check args and env vars
 major=$1
 minor=$2
 patch=$3
 export PATH=$CERC_GH_RELEASE_SCRIPTS_DIR:$PATH
 github_org="cerc-io"
 github_repository="stack-orchestrator"
 latest_package=$(ls -1t ./package/* | head -1)
 uploaded_package="./package/laconic-so"
 # Remove any old package
 rm ${uploaded_package}
 cp ${latest_package} ${uploaded_package}
 github_release_manager.sh \
        -l notused -t ${CERC_PACKAGE_RELEASE_GITHUB_TOKEN} \
        -o ${github_org} -r ${github_repository} \
        -d v${major}.${minor}.${patch} \
        -c create -m "Release v${major}.${minor}.${patch}"
 github_release_manager.sh \
        -l notused -t ${CERC_PACKAGE_RELEASE_GITHUB_TOKEN} \
        -o ${github_org} -r ${github_repository} \
        -d v${major}.${minor}.${patch} \
        -c upload ${uploaded_package}
@@ -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
@@ -0,0 +1,174 @@
 #!/usr/bin/env bash
 if [[ -n "$CERC_SCRIPT_DEBUG" ]]; then
    set -x
 fi
 install_dir=~/bin
 # Skip the package install stuff if so directed
 if ! [[ -n "$CERC_SO_INSTALL_SKIP_PACKAGES" ]]; then
 # First display a reasonable warning to the user unless run with -y
 if ! [[ $# -eq 1 && $1 == "-y" ]]; then
  echo "**************************************************************************************"
  echo "This script requires sudo privilege. It installs Laconic Stack Orchestrator"
  echo "into: ${install_dir}. It also *removes* any existing docker installed on"
  echo "this machine and then installs the latest docker release as well as other"
  echo "required packages."
  echo "Only proceed if you are sure you want to make those changes to this machine."
  echo "**************************************************************************************"
  read -p "Are you sure you want to proceed? " -n 1 -r
  echo
  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    exit 1
  fi
 fi
 # This script assumes root permissions on a fresh Ubuntu Digital Ocean droplet
 # with these recommended specs: 16 GB Memory / 8 Intel vCPUs / 320 GB Disk
 # TODO:
 #   Check python3 is available
 #   Check machine resources are sufficient
 # Determine if we are on Debian or Ubuntu
 linux_distro=$(lsb_release -a 2>/dev/null | grep "^Distributor ID:" | cut -f 2)
 # Some systems don't have lsb_release installed (e.g. ChromeOS) and so we try to
 # use /etc/os-release instead
 if [[ -z "$linux_distro" ]]; then
  if [[ -f "/etc/os-release" ]]; then
    distro_name_string=$(grep "^NAME=" /etc/os-release | cut -d '=' -f 2)
    if [[ $distro_name_string =~ Debian ]]; then
      linux_distro="Debian"
    elif [[ $distro_name_string =~ Ubuntu ]]; then
      linux_distro="Ubuntu"
    fi
  else
    echo "Failed to identify distro: /etc/os-release doesn't exist"
    exit 1
  fi
 fi
 case $linux_distro in
  Debian)
    echo "Installing docker for Debian"
    ;;
  Ubuntu)
    echo "Installing docker for Ubuntu"
    ;;
  *)
    echo "ERROR: Detected unknown distribution $linux_distro, can't install docker"
    exit 1
    ;;
 esac
 # dismiss the popups
 export DEBIAN_FRONTEND=noninteractive
 ## https://docs.docker.com/engine/install/ubuntu/
 ## https://docs.docker.com/engine/install/debian/
 ## https://superuser.com/questions/518859/ignore-packages-that-are-not-currently-installed-when-using-apt-get-remove1
 packages_to_remove="docker docker-engine docker.io containerd runc docker-compose docker-doc podman-docker"
 installed_packages_to_remove=""
 for package_to_remove in $(echo $packages_to_remove); do
  $(dpkg --info $package_to_remove &> /dev/null)
  if [[ $? -eq 0 ]]; then
    installed_packages_to_remove="$installed_packages_to_remove $package_to_remove"
  fi
 done
 # Enable stop on error now, since we needed it off for the code above
 set -euo pipefail  ## https://vaneyckt.io/posts/safer_bash_scripts_with_set_euxo_pipefail/
 if [[ -n "${installed_packages_to_remove}" ]]; then
  echo "**************************************************************************************"
  echo "Removing existing docker packages"
  sudo apt -y remove $installed_packages_to_remove
 fi
 echo "**************************************************************************************"
 echo "Installing dependencies"
 sudo apt -y update
 # laconic-so depends on jq
 sudo apt -y install jq
 # laconic-so depends on git
 sudo apt -y install git
 # curl used below
 sudo apt -y install curl 
 # docker repo add depends on gnupg and updated ca-certificates
 sudo apt -y install ca-certificates gnupg
 # Add dockerco package repository
 # For reasons not obvious, the dockerco instructions for installation on
 # Debian and Ubuntu are slightly different here
 case $linux_distro in
  Debian)
    sudo install -m 0755 -d /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    sudo chmod a+r /etc/apt/keyrings/docker.gpg
    ;;
  Ubuntu)
    sudo mkdir -m 0755 -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    ;;
  *)
    echo "ERROR: Detected unknown distribution $linux_distro, can't install docker"
    exit 1
    ;;
 esac
 echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/${linux_distro,,} \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 # Penny in the update jar
 sudo apt -y update
 echo "**************************************************************************************"
 echo "Installing docker"
 sudo apt -y install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
 # Allow the current user to use Docker
 sudo usermod -aG docker $USER
 # End of long if block: Skip the package install stuff if so directed
 fi
 echo "**************************************************************************************"
 echo "Installing laconic-so"
 # install latest `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}
 chmod +x ${install_filename}
 # Set up config file for self-update feature
 mkdir ~/.laconic-so
 echo "distribution-url: ${distribution_url}" >  ~/.laconic-so/config.yml
 echo "**************************************************************************************"
 # Check if our PATH line is already there
 path_add_command="export PATH=\$PATH:${install_dir}"
 if ! grep -q "${path_add_command}" ~/.profile
 then
  echo "Adding this line to the end of ~/.profile:"
  echo ${path_add_command}
  echo ${path_add_command} >> ~/.profile
 fi
 echo "**************************************************************************************"
 # PATH set here for commands run in this script
 export PATH=$PATH:${install_dir}
 echo Installed laconic-so version: $(laconic-so version)
 echo "**************************************************************************************"
 echo "The Laconic Stack Orchestrator program laconic-so has been installed at ${install_filename}"
 echo "The directory ${install_dir} has been added to PATH in *new* shells via ~/.profile"
 echo "**************************************************************************************"
 # Message the user to check docker is working for them
 echo "Please log in again (docker will not work in this current shell) then:"
 echo "test that docker is correctly installed and working for your user by running the"
 echo "command below (it should print a message beginning \"Hello from Docker!\"):"
 echo
 echo "docker run hello-world"
 echo
@@ -0,0 +1,17 @@
 #!/usr/bin/env bash
 # Usage: tag_new_release.sh <major> <minor> <patch>
 # Uses this script package to tag a new release:
 # User must define: CERC_GH_RELEASE_SCRIPTS_DIR
 # pointing to the location of that cloned repository
 # e.g. 
 # cd ~/projects
 # git clone https://github.com/cerc-io/github-release-api
 # cd ./stack-orchestrator
 # export CERC_GH_RELEASE_SCRIPTS_DIR=~/projects/github-release-api
 # ./scripts/publish_shiv_package_github.sh
 # TODO: check args and env vars
 major=$1
 minor=$2
 patch=$3
 export PATH=$CERC_GH_RELEASE_SCRIPTS_DIR:$PATH
 git_tag_manager.sh -M ${major} -m ${minor} -p ${patch} -t "Release ${major}.${minor}.${patch}"
@@ -6,23 +6,25 @@ with open("requirements.txt", "r", encoding="utf-8") as fh:
    requirements = fh.read()
 setup(
    name='laconic-stack-orchestrator',
-    version='0.0.5',
+    version='1.0.12',
    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',
    include_package_data=True,
    package_data={'': ['data/**']},
    classifiers=[
        "Programming Language :: Python :: 3.8",
        "Operating System :: OS Independent",
    ],
    entry_points={
-        'console_scripts': ['laconic-so=cli:cli'],
+        'console_scripts': ['laconic-so=stack_orchestrator.main:cli'],
    }
 )
@@ -0,0 +1,82 @@
 # 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
 from abc import ABC, abstractmethod
 from stack_orchestrator.deploy.deploy import get_stack_status
 from decouple import config
 def get_stack(config, stack):
    if stack == "package-registry":
        return package_registry_stack(config, stack)
    else:
        return base_stack(config, stack)
 class base_stack(ABC):
    def __init__(self, config, stack):
        self.config = config
        self.stack = stack
    @abstractmethod
    def ensure_available(self):
        pass
    @abstractmethod
    def get_url(self):
        pass
 class package_registry_stack(base_stack):
    def ensure_available(self):
        self.url = "<no registry url set>"
        # Check if we were given an external registry URL
        url_from_environment = os.environ.get("CERC_NPM_REGISTRY_URL")
        if url_from_environment:
            if self.config.verbose:
                print(f"Using package registry url from CERC_NPM_REGISTRY_URL: {url_from_environment}")
            self.url = url_from_environment
        else:
            # Otherwise we expect to use the local package-registry stack
            # First check if the stack is up
            registry_running = get_stack_status(self.config, "package-registry")
            if registry_running:
                # If it is available, get its mapped port and construct its URL
                if self.config.debug:
                    print("Found local package registry stack is up")
                # TODO: get url from deploy-stack
                self.url = "http://gitea.local:3000/api/packages/cerc-io/npm/"
            else:
                # If not, print a message about how to start it and return fail to the caller
                print("ERROR: The package-registry stack is not running, and no external registry "
                      "specified with CERC_NPM_REGISTRY_URL")
                print("ERROR: Start the local package registry with: laconic-so --stack package-registry deploy-system up")
                return False
        return True
    def get_url(self):
        return self.url
 def get_npm_registry_url():
    # If an auth token is not defined, we assume the default should be the cerc registry
    # If an auth token is defined, we assume the local gitea should be used.
    default_npm_registry_url = "http://gitea.local:3000/api/packages/cerc-io/npm/" if config(
        "CERC_NPM_AUTH_TOKEN", default=None
        ) else "https://git.vdb.to/api/packages/cerc-io/npm/"
    return config("CERC_NPM_REGISTRY_URL", default=default_npm_registry_url)
@@ -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).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}")
@@ -0,0 +1,173 @@
 # 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
 import os
 import sys
 from shutil import rmtree, copytree
 from decouple import config
 import click
 import importlib.resources
 from python_on_whales import docker, DockerException
 from stack_orchestrator.base import get_stack
 from stack_orchestrator.util import include_exclude_check, get_parsed_stack_config
 builder_js_image_name = "cerc/builder-js:local"
@click.command()
@click.option('--include', help="only build these packages")
@click.option('--exclude', help="don\'t build these packages")
@click.option("--force-rebuild", is_flag=True, default=False,
              help="Override existing target package version check -- force 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 npm packages required for a complete stack'''
    quiet = ctx.obj.quiet
    verbose = ctx.obj.verbose
    dry_run = ctx.obj.dry_run
    local_stack = ctx.obj.local_stack
    debug = ctx.obj.debug
    stack = ctx.obj.stack
    continue_on_error = ctx.obj.continue_on_error
    _ensure_prerequisites()
    # build-npms depends on having access to a writable package registry
    # so we check here that it is available
    package_registry_stack = get_stack(ctx.obj, "package-registry")
    registry_available = package_registry_stack.ensure_available()
    if not registry_available:
        print("FATAL: no npm registry available for build-npms command")
        sys.exit(1)
    npm_registry_url = package_registry_stack.get_url()
    npm_registry_url_token = config("CERC_NPM_AUTH_TOKEN", default=None)
    if not npm_registry_url_token:
        print("FATAL: CERC_NPM_AUTH_TOKEN is not defined")
        sys.exit(1)
    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"))
    build_root_path = os.path.join(dev_root_path, "build-trees")
    if verbose:
        print(f'Dev Root is: {dev_root_path}')
    if not os.path.isdir(dev_root_path):
        print('Dev root directory doesn\'t exist, creating')
        os.makedirs(dev_root_path)
    if not os.path.isdir(dev_root_path):
        print('Build root directory doesn\'t exist, creating')
        os.makedirs(build_root_path)
    # See: https://stackoverflow.com/a/20885799/1701505
    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()
    packages_in_scope = []
    if stack:
        stack_config = get_parsed_stack_config(stack)
        # TODO: syntax check the input here
        packages_in_scope = stack_config['npms']
    else:
        packages_in_scope = all_packages
    if verbose:
        print(f'Packages: {packages_in_scope}')
    def build_package(package):
        if not quiet:
            print(f"Building npm package: {package}")
        repo_dir = package
        repo_full_path = os.path.join(dev_root_path, repo_dir)
        # Copy the repo and build that to avoid propagating JS tooling file changes back into the cloned repo
        repo_copy_path = os.path.join(build_root_path, repo_dir)
        # First delete any old build tree
        if os.path.isdir(repo_copy_path):
            if verbose:
                print(f"Deleting old build tree: {repo_copy_path}")
            if not dry_run:
                rmtree(repo_copy_path)
        # Now copy the repo into the build tree location
        if verbose:
            print(f"Copying build tree from: {repo_full_path} to: {repo_copy_path}")
        if not dry_run:
            copytree(repo_full_path, repo_copy_path)
        build_command = ["sh", "-c", f"cd /workspace && build-npm-package-local-dependencies.sh {npm_registry_url}"]
        if not dry_run:
            if verbose:
                print(f"Executing: {build_command}")
            # Originally we used the PEP 584 merge operator:
            # envs = {"CERC_NPM_AUTH_TOKEN": npm_registry_url_token} | ({"CERC_SCRIPT_DEBUG": "true"} if debug else {})
            # but that isn't available in Python 3.8 (default in Ubuntu 20) so for now we use dict.update:
            envs = {"CERC_NPM_AUTH_TOKEN": npm_registry_url_token,
                    "LACONIC_HOSTED_CONFIG_FILE": "config-hosted.yml"  # Convention used by our web app packages
                    }
            envs.update({"CERC_SCRIPT_DEBUG": "true"} if debug else {})
            envs.update({"CERC_FORCE_REBUILD": "true"} if force_rebuild else {})
            envs.update({"CERC_CONTAINER_EXTRA_BUILD_ARGS": extra_build_args} if extra_build_args else {})
            try:
                docker.run(builder_js_image_name,
                           remove=True,
                           interactive=True,
                           tty=True,
                           user=f"{os.getuid()}:{os.getgid()}",
                           envs=envs,
                           # TODO: detect this host name in npm_registry_url rather than hard-wiring it
                           add_hosts=[("gitea.local", "host-gateway")],
                           volumes=[(repo_copy_path, "/workspace")],
                           command=build_command
                           )
                # Note that although the docs say that build_result should contain
                # the command output as a string, in reality it is always the empty string.
                # Since we detect errors via catching exceptions below, we can safely ignore it here.
            except DockerException as e:
                print(f"Error executing build for {package} in container:\n {e}")
                if not continue_on_error:
                    print("FATAL Error: build failed and --continue-on-error not set, exiting")
                    sys.exit(1)
                else:
                    print("****** Build Error, continuing because --continue-on-error is set")
        else:
            print("Skipped")
    for package in packages_in_scope:
        if include_exclude_check(package, include, exclude):
            build_package(package)
        else:
            if verbose:
                print(f"Excluding: {package}")
 def _ensure_prerequisites():
    # Check that the builder-js container is available and
    # Tell the user how to build it if not
    images = docker.image.list(builder_js_image_name)
    if len(images) == 0:
        print(f"FATAL: builder image: {builder_js_image_name} is required but was not found")
        print("Please run this command to create it: laconic-so --stack build-support build-containers")
        sys.exit(1)
@@ -1,4 +1,4 @@
-# Copyright © 2022 Cerc
+# 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
@@ -13,12 +13,17 @@
 # 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/>.
-def include_exclude_check(s, include, exclude):
+
-    if include is None and exclude is None:
+from dataclasses import dataclass
-        return True
+from pathlib import Path
-    if include is not None:
+from typing import Mapping
-        include_list = include.split(",")
+
-        return s in include_list
+
-    if exclude is not None:
+@dataclass
-        exclude_list = exclude.split(",")
+class BuildContext:
-        return s not in exclude_list
+    stack: str
    container: str
    container_build_dir: Path
    container_build_env: Mapping[str,str]
    dev_root_path: str
@@ -0,0 +1,43 @@
 # 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):
    # 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:
        all_containers = container_list_file.read().splitlines()
    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:
        containers_in_scope = all_containers
    if opts.o.verbose:
        print(f'Containers: {containers_in_scope}')
        if stack:
            print(f"Stack: {stack}")
    return containers_in_scope
@@ -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)
@@ -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")
@@ -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)
@@ -0,0 +1,27 @@
 # 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/>.
 from dataclasses import dataclass
@dataclass
 class CommandOptions:
    stack: str
    quiet: bool = False
    verbose: bool = False
    dry_run: bool = False
    local_stack: bool = False
    debug: bool = False
    continue_on_error: bool = False
@@ -0,0 +1,38 @@
 # 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"
 kind_config_filename = "kind-config.yml"
 kube_config_filename = "kubeconfig.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:
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1,2 @@`
							`Change this file to trigger running the fixturenet-eth-plugeth-arm-test CI job`
		`@@ -0,0 +1 @@`
							`Change this file to trigger running the test-container-registry CI job`
		`@@ -0,0 +1,2 @@`
							`Change this file to trigger running the test-database CI job`
							`Trigger test run`
		`@@ -0,0 +1,2 @@`
							`Change this file to trigger running the test-k8s-deploy CI job`
							`Trigger test on PR branch`
		`@@ -0,0 +1,3 @@`
							`Change this file to trigger running the fixturenet-laconicd-test CI job`

							`trigger`