update pod name

clean up readme formatting
fix typo in readme
2023-12-06 21:52:23 +00:00 · 2023-12-06 21:51:36 +00:00 · 2023-12-06 21:49:49 +00:00 · 2023-12-06 21:44:12 +00:00 · 2023-12-06 09:27:47 -07:00 · 2023-12-05 22:56:58 -07:00
56 changed files with 1862 additions and 243 deletions
@@ -0,0 +1,41 @@
+# keycloak
+
+Deploys a stand alone [keycloak](https://www.keycloak.org)
+
+## Clone required repositories
+
+```
+$ laconic-so --stack keycloak setup-repositories
+```
+
+## Build containers
+
+```
+$ laconic-so --stack keycloak build-containers
+```
+
+## Create a deployment
+
+```
+$ laconic-so --stack keycloak deploy init --map-ports-to-host any-same --output keycloak-spec.yml
+$ laconic-so deploy create --spec-file keycloak-spec.yml --deployment-dir keycloak-deployment
+```
+
+## Start the stack
+
+```
+$ laconic-so deployment --dir keycloak-deployment start
+```
+
+Display stack status:
+
+```
+$ laconic-so deployment --dir keycloak-deployment ps
+Running containers:
+```
+
+See stack logs:
+
+```
+$ laconic-so deployment --dir keycloak-deployment logs
+```
@@ -0,0 +1,14 @@
+# 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/>.
@@ -0,0 +1,13 @@
+version: "1.0"
+name: keycloak
+description: "Keycloak"
+repos:
+  - git.vdb.to/cerc-io/keycloak-reg-api
+  - git.vdb.to/cerc-io/keycloak-reg-ui
+containers:
+  - cerc/keycloak
+  - cerc/keycloak-reg-api
+  - cerc/keycloak-reg-ui
+  - cerc/webapp-base
+pods:
+  - keycloak
@@ -34,7 +34,7 @@ To test locally run:

 ## Running

-With `run-webapp` a new container will be launched with runtime configuration provided by `--env-file` (if specified) and published on an available port.  Multiple instances can be launched with different configuration.
+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**:
 ```
@@ -52,3 +52,13 @@ 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
+```
@@ -32,8 +32,9 @@ from stack_orchestrator.build import build_containers
@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):
+def command(ctx, base_container, source_repo, force_rebuild, extra_build_args, tag):
    '''build the specified webapp container'''

    quiet = ctx.obj.quiet
@@ -70,8 +71,11 @@ def command(ctx, base_container, source_repo, force_rebuild, extra_build_args):
    container_build_env["CERC_CONTAINER_BUILD_DOCKERFILE"] = os.path.join(container_build_dir,
                                                                    base_container.replace("/", "-"),
                                                                    "Dockerfile.webapp")
-    webapp_name = os.path.abspath(source_repo).split(os.path.sep)[-1]
-    container_build_env["CERC_CONTAINER_BUILD_TAG"] = f"cerc/{webapp_name}:local"
+    if not tag:
+        webapp_name = os.path.abspath(source_repo).split(os.path.sep)[-1]
+        container_build_env["CERC_CONTAINER_BUILD_TAG"] = f"cerc/{webapp_name}:local"
+    else:
+        container_build_env["CERC_CONTAINER_BUILD_TAG"] = tag

    build_containers.process_container(None, base_container, container_build_dir, container_build_env, dev_root_path, quiet,
                                       verbose, dry_run, continue_on_error)
@@ -13,12 +13,20 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.

+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_resigtry_key = "image-registry"
 kind_config_filename = "kind-config.yml"
 kube_config_filename = "kubeconfig.yml"
@@ -4,6 +4,6 @@ services:
    image: cerc/laconic-console-host:local
    environment:
      - CERC_WEBAPP_FILES_DIR=${CERC_WEBAPP_FILES_DIR:-/usr/local/share/.config/yarn/global/node_modules/@cerc-io/console-app/dist/production}
-      - LACONIC_HOSTED_ENDPOINT=${LACONIC_HOSTED_ENDPOINT:-http://localhost}
+      - LACONIC_HOSTED_ENDPOINT=${LACONIC_HOSTED_ENDPOINT:-http://localhost:9473}
    ports:
      - "80"
@@ -5,7 +5,7 @@ services:
    command: ["sh", "/docker-entrypoint-scripts.d/create-fixturenet.sh"]
    volumes:
      # The cosmos-sdk node's database directory:
-      - laconicd-data:/root/.laconicd/data
+      - laconicd-data:/root/.laconicd
      # TODO: look at folding these scripts into the container
      - ../config/fixturenet-laconicd/create-fixturenet.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh
      - ../config/fixturenet-laconicd/export-mykey.sh:/docker-entrypoint-scripts.d/export-mykey.sh
@@ -0,0 +1,22 @@
+version: "3.2"
+
+services:
+  proxy-server:
+    image: cerc/watcher-ts:local
+    restart: on-failure
+    working_dir: /app/packages/cli
+    environment:
+      ENABLE_PROXY: ${ENABLE_PROXY:-true}
+      PROXY_UPSTREAM: ${CERC_PROXY_UPSTREAM}
+      PROXY_ORIGIN_HEADER: ${CERC_PROXY_ORIGIN_HEADER}
+    command: ["sh", "-c", "./run.sh"]
+    volumes:
+      - ../config/proxy-server/run.sh:/app/packages/cli/run.sh
+    ports:
+      - "4000"
+    healthcheck:
+      test: ["CMD", "nc", "-v", "localhost", "4000"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 10s
@@ -0,0 +1,17 @@
+version: "3.2"
+
+services:
+  uniswap-interface:
+    image: cerc/uniswap-interface:local
+    restart: on-failure
+    environment:
+      - REACT_APP_INFURA_KEY=${CERC_INFURA_KEY}
+      - REACT_APP_AWS_API_ENDPOINT=${CERC_UNISWAP_GQL}
+    command: ["./build-app.sh"]
+    volumes:
+      - app_builds:/app-builds
+      - ../config/uniswap-interface/build-app.sh:/app/build-app.sh
+
+volumes:
+  app_builds:
+  app_globs:
@@ -0,0 +1,46 @@
+version: '3.7'
+
+services:
+  urbit-fake-ship:
+    restart: unless-stopped
+    image: tloncorp/vere
+    environment:
+      CERC_IPFS_GLOB_HOST_ENDPOINT: ${CERC_IPFS_GLOB_HOST_ENDPOINT:-http://ipfs-glob-host:5001}
+      CERC_IPFS_SERVER_ENDPOINT: ${CERC_IPFS_SERVER_ENDPOINT:-http://ipfs-glob-host:8080}
+    entrypoint: ["bash", "-c", "./run-urbit-ship.sh && ./deploy-uniswap-app.sh && tail -f /dev/null"]
+    volumes:
+      - urbit_data:/urbit
+      - app_builds:/app-builds
+      - app_globs:/app-globs
+      - ../config/urbit/run-urbit-ship.sh:/urbit/run-urbit-ship.sh
+      - ../config/uniswap-interface/deploy-uniswap-app.sh:/urbit/deploy-uniswap-app.sh
+    ports:
+      - "80"
+    healthcheck:
+      test: ["CMD", "nc", "-v", "localhost", "80"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 10s
+
+  ipfs-glob-host:
+    image: ipfs/kubo:master-2023-02-20-714a968
+    volumes:
+      - ipfs-import:/import
+      - ipfs-data:/data/ipfs
+    ports:
+      - "8080"
+      - "5001"
+    healthcheck:
+      test: ["CMD", "nc", "-v", "localhost", "5001"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 10s
+
+volumes:
+  urbit_data:
+  app_builds:
+  app_globs:
+  ipfs-import:
+  ipfs-data:
@@ -10,6 +10,7 @@ services:
      - POSTGRES_MULTIPLE_DATABASES=azimuth-watcher,azimuth-watcher-job-queue,censures-watcher,censures-watcher-job-queue,claims-watcher,claims-watcher-job-queue,conditional-star-release-watcher,conditional-star-release-watcher-job-queue,delegated-sending-watcher,delegated-sending-watcher-job-queue,ecliptic-watcher,ecliptic-watcher-job-queue,linear-star-release-watcher,linear-star-release-watcher-job-queue,polls-watcher,polls-watcher-job-queue
      - POSTGRES_EXTENSION=azimuth-watcher-job-queue:pgcrypto,censures-watcher-job-queue:pgcrypto,claims-watcher-job-queue:pgcrypto,conditional-star-release-watcher-job-queue:pgcrypto,delegated-sending-watcher-job-queue:pgcrypto,ecliptic-watcher-job-queue:pgcrypto,linear-star-release-watcher-job-queue:pgcrypto,polls-watcher-job-queue:pgcrypto,
      - POSTGRES_PASSWORD=password
+    command: ["postgres", "-c", "max_connections=200"]
    volumes:
      - ../config/postgresql/multiple-postgressql-databases.sh:/docker-entrypoint-initdb.d/multiple-postgressql-databases.sh
      - watcher_db_data:/var/lib/postgresql/data
@@ -22,6 +23,38 @@ services:
      retries: 15
      start_period: 10s

+  # Starts the azimuth-watcher job runner
+  azimuth-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CERC_HISTORICAL_BLOCK_RANGE: 500
+      CONTRACT_ADDRESS: 0x223c067F8CF28ae173EE5CafEa60cA44C335fecB
+      CONTRACT_NAME: Azimuth
+      STARTING_BLOCK: 6784880
+    working_dir: /app/packages/azimuth-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/azimuth-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/azimuth-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/azimuth-watcher/start-job-runner.sh
+    ports:
+      - "9000"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9000"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the azimuth-watcher server
  azimuth-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -29,8 +62,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      azimuth-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -52,6 +85,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the censures-watcher job runner
+  censures-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0x325f68d32BdEe6Ed86E7235ff2480e2A433D6189
+      CONTRACT_NAME: Censures
+      STARTING_BLOCK: 6784954
+    working_dir: /app/packages/censures-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/censures-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/censures-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/censures-watcher/start-job-runner.sh
+    ports:
+      - "9002"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9002"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the censures-watcher server
  censures-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -59,8 +123,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      censures-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -82,6 +146,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the claims-watcher job runner
+  claims-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0xe7e7f69b34D7d9Bd8d61Fb22C33b22708947971A
+      CONTRACT_NAME: Claims
+      STARTING_BLOCK: 6784941
+    working_dir: /app/packages/claims-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/claims-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/claims-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/claims-watcher/start-job-runner.sh
+    ports:
+      - "9004"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9004"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the claims-watcher server
  claims-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -89,8 +184,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      claims-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -112,6 +207,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the conditional-star-release-watcher job runner
+  conditional-star-release-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0x8C241098C3D3498Fe1261421633FD57986D74AeA
+      CONTRACT_NAME: ConditionalStarRelease
+      STARTING_BLOCK: 6828004
+    working_dir: /app/packages/conditional-star-release-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/conditional-star-release-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/conditional-star-release-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/conditional-star-release-watcher/start-job-runner.sh
+    ports:
+      - "9006"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9006"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the conditional-star-release-watcher server
  conditional-star-release-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -119,8 +245,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      conditional-star-release-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -142,6 +268,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the delegated-sending-watcher job runner
+  delegated-sending-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0xf6b461fE1aD4bd2ce25B23Fe0aff2ac19B3dFA76
+      CONTRACT_NAME: DelegatedSending
+      STARTING_BLOCK: 6784956
+    working_dir: /app/packages/delegated-sending-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/delegated-sending-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/delegated-sending-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/delegated-sending-watcher/start-job-runner.sh
+    ports:
+      - "9008"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9008"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the delegated-sending-watcher server
  delegated-sending-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -149,8 +306,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      delegated-sending-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -172,6 +329,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the ecliptic-watcher job runner
+  ecliptic-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0x33EeCbf908478C10614626A9D304bfe18B78DD73
+      CONTRACT_NAME: Ecliptic
+      STARTING_BLOCK: 13692129
+    working_dir: /app/packages/ecliptic-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/ecliptic-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/ecliptic-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/ecliptic-watcher/start-job-runner.sh
+    ports:
+      - "9010"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9010"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the ecliptic-watcher server
  ecliptic-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -179,8 +367,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      ecliptic-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -202,6 +390,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the linear-star-release-watcher job runner
+  linear-star-release-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0x86cd9cd0992F04231751E3761De45cEceA5d1801
+      CONTRACT_NAME: LinearStarRelease
+      STARTING_BLOCK: 6784943
+    working_dir: /app/packages/linear-star-release-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/linear-star-release-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/linear-star-release-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/linear-star-release-watcher/start-job-runner.sh
+    ports:
+      - "9012"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9012"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the linear-star-release-watcher server
  linear-star-release-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -209,8 +428,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      linear-star-release-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -232,6 +451,37 @@ services:
    extra_hosts:
      - "host.docker.internal:host-gateway"

+  # Starts the polls-watcher job runner
+  polls-watcher-job-runner:
+    image: cerc/watcher-azimuth:local
+    restart: unless-stopped
+    depends_on:
+      watcher-db:
+        condition: service_healthy
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
+      CERC_IPLD_ETH_GQL: ${CERC_IPLD_ETH_GQL}
+      CONTRACT_ADDRESS: 0x7fEcaB617c868Bb5996d99D95200D2Fa708218e4
+      CONTRACT_NAME: Polls
+      STARTING_BLOCK: 6784912
+    working_dir: /app/packages/polls-watcher
+    command: "./start-job-runner.sh"
+    volumes:
+      - ../config/watcher-azimuth/watcher-config-template.toml:/app/packages/polls-watcher/environments/watcher-config-template.toml
+      - ../config/watcher-azimuth/merge-toml.js:/app/packages/polls-watcher/merge-toml.js
+      - ../config/watcher-azimuth/start-job-runner.sh:/app/packages/polls-watcher/start-job-runner.sh
+    ports:
+      - "9014"
+    healthcheck:
+      test: ["CMD", "nc", "-vz", "localhost", "9014"]
+      interval: 20s
+      timeout: 5s
+      retries: 15
+      start_period: 5s
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
  # Starts the polls-watcher server
  polls-watcher-server:
    image: cerc/watcher-azimuth:local
@@ -239,8 +489,8 @@ services:
    depends_on:
      watcher-db:
        condition: service_healthy
-    env_file:
-      - ../config/watcher-azimuth/watcher-params.env
+      polls-watcher-job-runner:
+        condition: service_healthy
    environment:
      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
      CERC_IPLD_ETH_RPC: ${CERC_IPLD_ETH_RPC}
@@ -0,0 +1,8 @@
+services:
+  webapp:
+    image: cerc/webapp-container:local
+    restart: always
+    environment:
+      CERC_SCRIPT_DEBUG: ${CERC_SCRIPT_DEBUG}
+    ports:
+      - "3000"
@@ -14,104 +14,111 @@ LOGLEVEL="info"
 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; }
+if [ "$1" == "clean" ] || [ ! -d "$HOME/.laconicd/data/blockstore.db" ]; then
+  # 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*
+  # remove existing daemon and client
+  rm -rf $HOME/.laconicd/*
+  rm -rf $HOME/.laconic/*

-make install
-
-laconicd config keyring-backend $KEYRING
-laconicd config chain-id $CHAINID
-
-# if $KEY exists it should be deleted
-laconicd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO
-
-# Set moniker and chain-id for Ethermint (Moniker can be anything, chain-id must be an integer)
-laconicd init $MONIKER --chain-id $CHAINID
-
-# Change parameter token denominations to aphoton
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["mint"]["params"]["mint_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-# Custom modules
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commit_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveal_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_minimum_bid"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-if [[ "$TEST_REGISTRY_EXPIRY" == "true" ]]; then
-  echo "Setting timers for expiry tests."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-if [[ "$TEST_AUCTION_ENABLED" == "true" ]]; then
-  echo "Enabling auction and setting timers."
-
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_enabled"]=true' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="300s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commits_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveals_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-fi
-
-# increase block time (?)
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["time_iota_ms"]="1000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# Set gas limit in genesis
-cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="10000000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
-
-# disable produce empty block
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-  else
-    sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
-fi
-
-if [[ $1 == "pending" ]]; then
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-      sed -i '' 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i '' 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-  else
-      sed -i 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
-      sed -i 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
+  if [ -n "`which make`" ]; then
+    make install
  fi
-fi

-# Allocate genesis accounts (cosmos formatted addresses)
-laconicd add-genesis-account $KEY 100000000000000000000000000aphoton --keyring-backend $KEYRING
+  laconicd config keyring-backend $KEYRING
+  laconicd config chain-id $CHAINID

-# Sign genesis transaction
-laconicd gentx $KEY 1000000000000000000000aphoton --keyring-backend $KEYRING --chain-id $CHAINID
+  # if $KEY exists it should be deleted
+  laconicd keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO

-# Collect genesis tx
-laconicd collect-gentxs
+  # Set moniker and chain-id for Ethermint (Moniker can be anything, chain-id must be an integer)
+  laconicd init $MONIKER --chain-id $CHAINID

-# Run this to ensure everything worked and that the genesis file is setup correctly
-laconicd validate-genesis
+  # Change parameter token denominations to aphoton
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["mint"]["params"]["mint_denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  # Custom modules
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commit_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveal_fee"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_minimum_bid"]["denom"]="aphoton"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json

-if [[ $1 == "pending" ]]; then
-  echo "pending mode is on, please wait for the first block committed."
+  if [[ "$TEST_REGISTRY_EXPIRY" == "true" ]]; then
+    echo "Setting timers for expiry tests."
+
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["record_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  fi
+
+  if [[ "$TEST_AUCTION_ENABLED" == "true" ]]; then
+    echo "Enabling auction and setting timers."
+
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_enabled"]=true' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_rent_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_grace_period"]="300s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_commits_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+    cat $HOME/.laconicd/config/genesis.json | jq '.app_state["registry"]["params"]["authority_auction_reveals_duration"]="60s"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+  fi
+
+  # increase block time (?)
+  cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["time_iota_ms"]="1000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+
+  # Set gas limit in genesis
+  cat $HOME/.laconicd/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="10000000"' > $HOME/.laconicd/config/tmp_genesis.json && mv $HOME/.laconicd/config/tmp_genesis.json $HOME/.laconicd/config/genesis.json
+
+  # disable produce empty block
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+      sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
+    else
+      sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' $HOME/.laconicd/config/config.toml
+  fi
+
+  if [[ $1 == "pending" ]]; then
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        sed -i '' 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
+        sed -i '' 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
+    else
+        sed -i 's/create_empty_blocks_interval = "0s"/create_empty_blocks_interval = "30s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_propose = "3s"/timeout_propose = "30s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_propose_delta = "500ms"/timeout_propose_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_prevote = "1s"/timeout_prevote = "10s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_prevote_delta = "500ms"/timeout_prevote_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_precommit = "1s"/timeout_precommit = "10s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_precommit_delta = "500ms"/timeout_precommit_delta = "5s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_commit = "5s"/timeout_commit = "150s"/g' $HOME/.laconicd/config/config.toml
+        sed -i 's/timeout_broadcast_tx_commit = "10s"/timeout_broadcast_tx_commit = "150s"/g' $HOME/.laconicd/config/config.toml
+    fi
+  fi
+
+  # Allocate genesis accounts (cosmos formatted addresses)
+  laconicd add-genesis-account $KEY 100000000000000000000000000aphoton --keyring-backend $KEYRING
+
+  # Sign genesis transaction
+  laconicd gentx $KEY 1000000000000000000000aphoton --keyring-backend $KEYRING --chain-id $CHAINID
+
+  # Collect genesis tx
+  laconicd collect-gentxs
+
+  # Run this to ensure everything worked and that the genesis file is setup correctly
+  laconicd validate-genesis
+
+  if [[ $1 == "pending" ]]; then
+    echo "pending mode is on, please wait for the first block committed."
+  fi
+else
+  echo "Using existing database at $HOME/.laconicd.  To replace, run '`basename $0` clean'"
 fi

 # Start the node (remove the --pruning=nothing flag if historical queries are not needed)
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+if [ "$ENABLE_PROXY" = "true" ]; then
+  echo "Proxy server enabled"
+  yarn proxy
+else
+  echo "Proxy server disabled, exiting"
+  exit 0
+fi
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -e
+if [ -n "$CERC_SCRIPT_DEBUG" ]; then
+  set -x
+fi
+
+# Check and exit if a deployment already exists (on restarts)
+if [ -d /app-builds/uniswap/build ]; then
+  echo "Build already exists, remove volume to rebuild"
+  exit 0
+fi
+
+yarn build
+
+# Move build to app-builds so urbit can deploy it
+mkdir /app-builds/uniswap
+cp -r ./build /app-builds/uniswap/
@@ -0,0 +1,149 @@
+#!/bin/bash
+
+if [ -n "$CERC_SCRIPT_DEBUG" ]; then
+  set -x
+fi
+
+echo "Using IPFS endpoint ${CERC_IPFS_GLOB_HOST_ENDPOINT} for hosting globs"
+echo "Using IPFS server endpoint ${CERC_IPFS_SERVER_ENDPOINT} for reading glob files"
+ipfs_host_endpoint=${CERC_IPFS_GLOB_HOST_ENDPOINT}
+ipfs_server_endpoint=${CERC_IPFS_SERVER_ENDPOINT}
+
+uniswap_app_build='/app-builds/uniswap/build'
+uniswap_desk_dir='/urbit/zod/uniswap'
+
+if [ -d ${uniswap_desk_dir} ]; then
+  echo "Uniswap desk dir already exists, skipping deployment..."
+  exit 0
+fi
+
+# Fire curl requests to perform operations on the ship
+dojo () {
+  curl -s --data '{"source":{"dojo":"'"$1"'"},"sink":{"stdout":null}}' http://localhost:12321
+}
+
+hood () {
+  curl -s --data '{"source":{"dojo":"+hood/'"$1"'"},"sink":{"app":"hood"}}' http://localhost:12321
+}
+
+# Create/mount a uniswap desk
+hood "merge %uniswap our %landscape"
+hood "mount %uniswap"
+
+# Loop until the uniswap build appears
+while [ ! -d ${uniswap_app_build} ]; do
+  echo "Uniswap app build not found, retrying in 5s..."
+  sleep 5
+done
+echo "Build found..."
+
+# Copy over build to desk data dir
+cp -r ${uniswap_app_build} ${uniswap_desk_dir}
+
+# Create a mark file for .map file type
+cat << EOF > "${uniswap_desk_dir}/mar/map.hoon"
+::
+::::  /hoon/map/mar
+  ::  Mark for js source maps
+/?    310
+::
+=,  eyre
+|_  mud=@
++  grow
+  |%
+  ++  mime  [/application/octet-stream (as-octs:mimes:html (@t mud))]
+  --
++  grab
+  |%                                                    ::  convert from
+  ++  mime  |=([p=mite q=octs] (@t q.q))
+  ++  noun  cord                                        ::  clam from %noun
+  --
++  grad  %mime
+--
+EOF
+
+# Create a mark file for .woff file type
+cat << EOF > "${uniswap_desk_dir}/mar/woff.hoon"
+|_  dat=octs
++  grow
+  |%
+  ++  mime  [/font/woff dat]
+  --
++  grab
+  |%
+  ++  mime  |=([=mite =octs] octs)
+  ++  noun  octs
+  --
++  grad  %mime
+--
+EOF
+
+# Create a mark file for .ttf file type
+cat << EOF > "${uniswap_desk_dir}/mar/ttf.hoon"
+|_  dat=octs
++  grow
+  |%
+  ++  mime  [/font/ttf dat]
+  --
++  grab
+  |%
+  ++  mime  |=([=mite =octs] octs)
+  ++  noun  octs
+  --
++  grad  %mime
+--
+EOF
+
+rm "${uniswap_desk_dir}/desk.bill"
+rm "${uniswap_desk_dir}/desk.ship"
+
+# Commit changes and create a glob
+hood "commit %uniswap"
+dojo "-landscape!make-glob %uniswap /build"
+
+glob_file=$(ls -1 -c zod/.urb/put | head -1)
+echo "Created glob file: ${glob_file}"
+
+upload_response=$(curl -X POST -F file=@./zod/.urb/put/${glob_file} ${ipfs_host_endpoint}/api/v0/add)
+glob_cid=$(echo "$upload_response" | grep -o '"Hash":"[^"]*' | sed 's/"Hash":"//')
+
+echo "Glob file uploaded to IFPS:"
+echo "{ cid: ${glob_cid}, filename: ${glob_file} }"
+
+# Curl and wait for the glob to be hosted
+glob_url="${ipfs_server_endpoint}/ipfs/${glob_cid}?filename=${glob_file}"
+
+echo "Checking if glob file hosted at ${glob_url}"
+while true; do
+  response=$(curl -sL -w "%{http_code}" -o /dev/null "$glob_url")
+
+  if [ $response -eq 200 ]; then
+    echo "File found at $glob_url"
+    break  # Exit the loop if the file is found
+  else
+    echo "File not found. Retrying in a few seconds..."
+    sleep 5
+  fi
+done
+
+glob_hash=$(echo "$glob_file" | sed "s/glob-\([a-z0-9\.]*\).glob/\1/")
+
+# Update the docket file
+cat << EOF > "${uniswap_desk_dir}/desk.docket-0"
+:~  title+'Uniswap'
+    info+'Self-hosted uniswap frontend.'
+    color+0xcd.75df
+    image+'https://logowik.com/content/uploads/images/uniswap-uni7403.jpg'
+    base+'uniswap'
+    glob-http+['${glob_url}' ${glob_hash}]
+    version+[0 0 1]
+    website+'https://uniswap.org/'
+    license+'MIT'
+==
+EOF
+
+# Commit changes and install the app
+hood "commit %uniswap"
+hood "install our %uniswap"
+
+echo "Uniswap app installed"
@@ -0,0 +1,110 @@
+#!/bin/bash
+
+# $1: Glob file URL (eg. https://xyz.com/glob-0vabcd.glob)
+# $2: Glob file hash (eg. 0vabcd)
+# $3: Urbit ship's pier dir (default: ./zod)
+
+if [ "$#" -lt 2 ]; then
+  echo "Insufficient arguments"
+  exit 0
+fi
+
+glob_url=$1
+glob_hash=$2
+echo "Using glob file from ${glob_url} with hash ${glob_hash}"
+
+# Default pier dir: ./zod
+# Default desk dir: ./zod/uniswap
+pier_dir="${3:-./zod}"
+uniswap_desk_dir="${pier_dir}/uniswap"
+echo "Using ${uniswap_desk_dir} as the Uniswap desk dir path"
+
+# Fire curl requests to perform operations on the ship
+dojo () {
+  curl -s --data '{"source":{"dojo":"'"$1"'"},"sink":{"stdout":null}}' http://localhost:12321
+}
+
+hood () {
+  curl -s --data '{"source":{"dojo":"+hood/'"$1"'"},"sink":{"app":"hood"}}' http://localhost:12321
+}
+
+# Create/mount a uniswap desk
+hood "merge %uniswap our %landscape"
+hood "mount %uniswap"
+
+# Create a mark file for .map file type
+cat << EOF > "${uniswap_desk_dir}/mar/map.hoon"
+::
+::::  /hoon/map/mar
+  ::  Mark for js source maps
+/?    310
+::
+=,  eyre
+|_  mud=@
++  grow
+  |%
+  ++  mime  [/application/octet-stream (as-octs:mimes:html (@t mud))]
+  --
++  grab
+  |%                                                    ::  convert from
+  ++  mime  |=([p=mite q=octs] (@t q.q))
+  ++  noun  cord                                        ::  clam from %noun
+  --
++  grad  %mime
+--
+EOF
+
+# Create a mark file for .woff file type
+cat << EOF > "${uniswap_desk_dir}/mar/woff.hoon"
+|_  dat=octs
++  grow
+  |%
+  ++  mime  [/font/woff dat]
+  --
++  grab
+  |%
+  ++  mime  |=([=mite =octs] octs)
+  ++  noun  octs
+  --
++  grad  %mime
+--
+EOF
+
+# Create a mark file for .ttf file type
+cat << EOF > "${uniswap_desk_dir}/mar/ttf.hoon"
+|_  dat=octs
++  grow
+  |%
+  ++  mime  [/font/ttf dat]
+  --
++  grab
+  |%
+  ++  mime  |=([=mite =octs] octs)
+  ++  noun  octs
+  --
++  grad  %mime
+--
+EOF
+
+rm "${uniswap_desk_dir}/desk.bill"
+rm "${uniswap_desk_dir}/desk.ship"
+
+# Update the docket file
+cat << EOF > "${uniswap_desk_dir}/desk.docket-0"
+:~  title+'Uniswap'
+    info+'Self-hosted uniswap frontend.'
+    color+0xcd.75df
+    image+'https://logowik.com/content/uploads/images/uniswap-uni7403.jpg'
+    base+'uniswap'
+    glob-http+['${glob_url}' ${glob_hash}]
+    version+[0 0 1]
+    website+'https://uniswap.org/'
+    license+'MIT'
+==
+EOF
+
+# Commit changes and install the app
+hood "commit %uniswap"
+hood "install our %uniswap"
+
+echo "Uniswap app installed"
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+# $1: Remote user host
+# $2: Remote Urbit ship's pier dir path (eg. /home/user/zod)
+# $3: Glob file URL (eg. https://xyz.com/glob-0vabcd.glob)
+# $4: Glob file hash (eg. 0vabcd)
+
+if [ "$#" -ne 4 ]; then
+  echo "Incorrect number of arguments"
+  echo "Usage: $0 <username@remote_host> </path/to/remote/pier/folder> <glob_url> <glob_hash>"
+  exit 1
+fi
+
+remote_user_host="$1"
+remote_pier_folder="$2"
+glob_url="$3"
+glob_hash="$4"
+
+installation_script="./install-uniswap-app.sh"
+
+ssh "$remote_user_host" "bash -s $glob_url $glob_hash $remote_pier_folder" < "$installation_script"
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -e
+if [ -n "$CERC_SCRIPT_DEBUG" ]; then
+  set -x
+fi
+
+pier_dir="/urbit/zod"
+
+# Run urbit ship in daemon mode
+# Check if the directory exists
+if [ -d "$pier_dir" ]; then
+  echo "Pier directory already exists, rebooting..."
+  urbit -d zod
+else
+  echo "Creating a new fake ship..."
+  urbit -d -F zod
+fi
@@ -0,0 +1,28 @@
+#!/bin/sh
+set -e
+if [ -n "$CERC_SCRIPT_DEBUG" ]; then
+  set -x
+fi
+
+echo "Using IPLD ETH RPC endpoint ${CERC_IPLD_ETH_RPC}"
+echo "Using IPLD GQL endpoint ${CERC_IPLD_ETH_GQL}"
+echo "Using historicalLogsBlockRange ${CERC_HISTORICAL_BLOCK_RANGE:-2000}"
+
+# Replace env variables in template TOML file
+# Read in the config template TOML file and modify it
+WATCHER_CONFIG_TEMPLATE=$(cat environments/watcher-config-template.toml)
+WATCHER_CONFIG=$(echo "$WATCHER_CONFIG_TEMPLATE" | \
+  sed -E "s|REPLACE_WITH_CERC_IPLD_ETH_RPC|${CERC_IPLD_ETH_RPC}|g; \
+          s|REPLACE_WITH_CERC_IPLD_ETH_GQL|${CERC_IPLD_ETH_GQL}|g; \
+          s|REPLACE_WITH_CERC_HISTORICAL_BLOCK_RANGE|${CERC_HISTORICAL_BLOCK_RANGE:-2000}| ")
+
+# Write the modified content to a new file
+echo "$WATCHER_CONFIG" > environments/watcher-config.toml
+
+# Merge SO watcher config with existing config file
+node merge-toml.js
+
+yarn watch:contract --address $CONTRACT_ADDRESS --kind $CONTRACT_NAME --checkpoint true --starting-block $STARTING_BLOCK
+
+echo 'yarn job-runner'
+yarn job-runner
@@ -4,18 +4,17 @@ if [ -n "$CERC_SCRIPT_DEBUG" ]; then
  set -x
 fi

-CERC_IPLD_ETH_RPC="${CERC_IPLD_ETH_RPC:-${DEFAULT_CERC_IPLD_ETH_RPC}}"
-CERC_IPLD_ETH_GQL="${CERC_IPLD_ETH_GQL:-${DEFAULT_CERC_IPLD_ETH_GQL}}"
-
 echo "Using IPLD ETH RPC endpoint ${CERC_IPLD_ETH_RPC}"
 echo "Using IPLD GQL endpoint ${CERC_IPLD_ETH_GQL}"
+echo "Using historicalLogsBlockRange ${CERC_HISTORICAL_BLOCK_RANGE:-2000}"

 # Replace env variables in template TOML file
 # Read in the config template TOML file and modify it
 WATCHER_CONFIG_TEMPLATE=$(cat environments/watcher-config-template.toml)
 WATCHER_CONFIG=$(echo "$WATCHER_CONFIG_TEMPLATE" | \
  sed -E "s|REPLACE_WITH_CERC_IPLD_ETH_RPC|${CERC_IPLD_ETH_RPC}|g; \
-          s|REPLACE_WITH_CERC_IPLD_ETH_GQL|${CERC_IPLD_ETH_GQL}| ")
+          s|REPLACE_WITH_CERC_IPLD_ETH_GQL|${CERC_IPLD_ETH_GQL}|g; \
+          s|REPLACE_WITH_CERC_HISTORICAL_BLOCK_RANGE|${CERC_HISTORICAL_BLOCK_RANGE:-2000}| ")

 # Write the modified content to a new file
 echo "$WATCHER_CONFIG" > environments/watcher-config.toml
@@ -2,6 +2,9 @@
  host = "0.0.0.0"
  maxSimultaneousRequests = -1

+[metrics]
+  host = "0.0.0.0"
+
 [database]
  host = "watcher-db"
  port = 5432
@@ -12,3 +15,7 @@
  [upstream.ethServer]
    gqlApiEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_GQL"
    rpcProviderEndpoint = "REPLACE_WITH_CERC_IPLD_ETH_RPC"
+
+[jobQueue]
+  historicalLogsBlockRange = REPLACE_WITH_CERC_HISTORICAL_BLOCK_RANGE
+  blockDelayInMilliSecs = 12000
@@ -1,5 +0,0 @@
-# Defaults
-
-# ipld-eth-server endpoints
-DEFAULT_CERC_IPLD_ETH_RPC=
-DEFAULT_CERC_IPLD_ETH_GQL=
@@ -2,5 +2,5 @@

 services:
  wns:
-    server: 'LACONIC_HOSTED_ENDPOINT:9473/api'
-    webui: 'LACONIC_HOSTED_ENDPOINT:9473/console'
+    server: 'LACONIC_HOSTED_ENDPOINT/api'
+    webui: 'LACONIC_HOSTED_ENDPOINT/console'
@@ -24,6 +24,8 @@ RUN \
    && su ${USERNAME} -c "npm config -g set prefix ${NPM_GLOBAL}" \
    # Install eslint
    && su ${USERNAME} -c "umask 0002 && npm install -g eslint" \
+    # Install semver
+    && su ${USERNAME} -c "umask 0002 && npm install -g semver" \
    && npm cache clean --force > /dev/null 2>&1

 # [Optional] Uncomment this section to install additional OS packages.
@@ -4,10 +4,12 @@ if [ -n "$CERC_SCRIPT_DEBUG" ]; then
    set -x
 fi

+CERC_MIN_NEXTVER=13.4.2
+
 CERC_NEXT_VERSION="${CERC_NEXT_VERSION:-keep}"
 CERC_BUILD_TOOL="${CERC_BUILD_TOOL}"
 if [ -z "$CERC_BUILD_TOOL" ]; then
-  if [ -f "yarn.lock" ] && [ ! -f "package-lock.json" ]; then
+  if [ -f "yarn.lock" ]; then
    CERC_BUILD_TOOL=yarn
  else
    CERC_BUILD_TOOL=npm
@@ -101,13 +103,35 @@ cat package.dist | jq '.scripts.cerc_compile = "next experimental-compile"' | jq
 CUR_NEXT_VERSION="`jq -r '.dependencies.next' package.json`"

 if [ "$CERC_NEXT_VERSION" != "keep" ] && [ "$CUR_NEXT_VERSION" != "$CERC_NEXT_VERSION" ]; then
-  echo "Changing 'next' version specifier from '$CUR_NEXT_VERSION' to '$CERC_NEXT_VERSION' (set with --build-arg CERC_NEXT_VERSION)"
+  echo "Changing 'next' version specifier from '$CUR_NEXT_VERSION' to '$CERC_NEXT_VERSION' (set with '--extra-build-args \"--build-arg CERC_NEXT_VERSION=$CERC_NEXT_VERSION\"')"
  cat package.json | jq ".dependencies.next = \"$CERC_NEXT_VERSION\"" | sponge package.json
-else
-  echo "'next' version specifier '$CUR_NEXT_VERSION' (override with --build-arg CERC_NEXT_VERSION)"
 fi

 $CERC_BUILD_TOOL install || exit 1
+
+CUR_NEXT_VERSION=`jq -r '.version' node_modules/next/package.json`
+
+semver -p -r ">=$CERC_MIN_NEXTVER" $CUR_NEXT_VERSION
+if [ $? -ne 0 ]; then
+  cat <<EOF
+
+###############################################################################
+
+WARNING: 'next' $CUR_NEXT_VERSION < minimum version $CERC_MIN_NEXTVER.
+
+Attempting to build with '^$CERC_MIN_NEXTVER'.  If this fails, you should upgrade
+the dependency in your webapp, or specify an explicit 'next' version
+to use for the build with:
+
+     --extra-build-args "--build-arg CERC_NEXT_VERSION=<version>"
+
+###############################################################################
+
+EOF
+  cat package.json | jq ".dependencies.next = \"^$CERC_MIN_NEXTVER\"" | sponge package.json
+  $CERC_BUILD_TOOL install || exit 1
+fi
+
 $CERC_BUILD_TOOL run cerc_compile || exit 1

 exit 0
@@ -0,0 +1,10 @@
+FROM node:18.17.1-alpine3.18
+
+RUN apk --update --no-cache add git make alpine-sdk bash
+
+WORKDIR /app
+
+COPY . .
+
+RUN echo "Building uniswap-interface" && \
+    yarn
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# Build the uniswap-interface image
+source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
+
+# See: https://stackoverflow.com/a/246128/1701505
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+docker build -t cerc/uniswap-interface:local -f ${SCRIPT_DIR}/Dockerfile ${build_command_args} ${CERC_REPO_BASE_DIR}/uniswap-interface
@@ -0,0 +1,7 @@
+FROM python:3.13.0a2-alpine3.18
+
+RUN apk --update --no-cache add alpine-sdk jq bash curl wget
+
+WORKDIR /app
+
+ENTRYPOINT [ "bash" ]
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# Build the urbit-globs-host image
+
+source ${CERC_CONTAINER_BASE_DIR}/build-base.sh
+
+# See: https://stackoverflow.com/a/246128/1701505
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+docker build -t cerc/urbit-globs-host:local -f ${SCRIPT_DIR}/Dockerfile ${build_command_args} ${SCRIPT_DIR}
@@ -59,3 +59,4 @@ cerc/ponder
 cerc/nitro-rpc-client
 cerc/watcher-merkl-sushiswap-v3
 cerc/watcher-sushiswap-v3
+cerc/uniswap-interface
@@ -49,3 +49,4 @@ github.com/cerc-io/mobymask-snap
 github.com/cerc-io/ponder
 github.com/cerc-io/merkl-sushiswap-v3-watcher-ts
 github.com/cerc-io/sushiswap-v3-watcher-ts
+github.com/cerc-io/uniswap-interface
@@ -9,19 +9,11 @@ Prerequisite: `ipld-eth-server` RPC and GQL endpoints
 Clone required repositories:

 ```bash
-laconic-so --stack azimuth setup-repositories
+laconic-so --stack azimuth setup-repositories --pull
 ```

 NOTE: If the repository already exists and checked out to a different version, `setup-repositories` command will throw an error.
-For getting around this, the `azimuth-watcher-ts` repository can be removed and then run the command.
-
-Checkout to the required versions and branches in repos
-
-```bash
-# azimuth-watcher-ts
-cd ~/cerc/azimuth-watcher-ts
-git checkout v0.1.0
-```
+For getting around this, the `azimuth-watcher-ts` repository can be removed and then run the command again.

 Build the container images:

@@ -31,42 +23,85 @@ laconic-so --stack azimuth build-containers

 This should create the required docker images in the local image registry.

-### Configuration
+## Create a deployment

-* Create and update an env file to be used in the next step:
+First, create a spec file for the deployment, which will map the stack's ports and volumes to the host:
+```bash
+laconic-so --stack azimuth deploy init --output azimuth-spec.yml
+```
+
+### Ports
+
+Edit `network` in spec file to map container ports to same ports in host
+
+```yaml
+...
+network:
+  ports:
+    watcher-db:
+     - 0.0.0.0:15432:5432
+    azimuth-watcher-server:
+     - 0.0.0.0:3001:3001
+    censures-watcher-server:
+     - 0.0.0.0:3002:3002
+    claims-watcher-server:
+     - 0.0.0.0:3003:3003
+    conditional-star-release-watcher-server:
+     - 0.0.0.0:3004:3004
+    delegated-sending-watcher-server:
+     - 0.0.0.0:3005:3005
+    ecliptic-watcher-server:
+     - 0.0.0.0:3006:3006
+    linear-star-release-watcher-server:
+     - 0.0.0.0:3007:3007
+    polls-watcher-server:
+     - 0.0.0.0:3008:3008
+    gateway-server:
+     - 0.0.0.0:4000:4000
+...
+```
+
+### Data volumes
+Container data volumes are bind-mounted to specified paths in the host filesystem.
+The default setup (generated by `laconic-so deploy init`) places the volumes in the `./data` subdirectory of the deployment directory. The default mappings can be customized by editing the "spec" file generated by `laconic-so deploy init`.
+
+---
+
+Once you've made any needed changes to the spec file, create a deployment from it:
+```bash
+laconic-so --stack azimuth deploy create --spec-file azimuth-spec.yml --deployment-dir azimuth-deployment
+```
+
+## Set env variables
+
+Inside the deployment directory, open the file `config.env` and add variable to update RPC endpoint :

  ```bash
-  # External ipld-eth-server endpoints
+  # External RPC endpoints
  CERC_IPLD_ETH_RPC=
-  CERC_IPLD_ETH_GQL=
  ```

-* NOTE: If `ipld-eth-server` is running on the host machine, use `host.docker.internal` as the hostname to access host ports
+* NOTE: If RPC endpoint is on the host machine, use `host.docker.internal` as the hostname to access the host port, or use the `ip a` command to find the IP address of the `docker0` interface (this will usually be something like `172.17.0.1` or `172.18.0.1`)

-### Deploy the stack
+## Start the stack

-* Deploy the containers:
-
-  ```bash
-  laconic-so --stack azimuth deploy-system --env-file <PATH_TO_ENV_FILE> up
-  ```
+Start the deployment:
+```bash
+laconic-so deployment --dir azimuth-deployment start
+```

 * List and check the health status of all the containers using `docker ps` and wait for them to be `healthy`

 ## Clean up

-Stop all the services running in background:
+To stop all azimuth services running in the background, while preserving chain data:

 ```bash
-laconic-so --stack azimuth deploy-system down
+laconic-so deployment --dir azimuth-deployment stop
 ```

-Clear volumes created by this stack:
+To stop all azimuth services and also delete data:

 ```bash
-# List all relevant volumes
-docker volume ls -q --filter "name=.*watcher_db_data"
-
-# Remove all the listed volumes
-docker volume rm $(docker volume ls -q --filter "name=.*watcher_db_data")
+laconic-so deployment --dir azimuth-deployment stop --delete-volumes
 ```
@@ -1,7 +1,7 @@
 version: "1.0"
 name: azimuth
 repos:
-  - github.com/cerc-io/azimuth-watcher-ts@v0.1.1
+  - github.com/cerc-io/azimuth-watcher-ts@v0.1.2
 containers:
  - cerc/watcher-azimuth
 pods:
@@ -0,0 +1,79 @@
+# Proxy Server
+
+Instructions to setup and deploy a HTTP proxy server
+
+## Setup
+
+Clone required repository:
+
+```bash
+laconic-so --stack proxy-server setup-repositories --pull
+
+# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
+```
+
+Build the container image:
+
+```bash
+laconic-so --stack proxy-server build-containers
+```
+
+## Create a deployment
+
+* First, create a spec file for the deployment, which will allow mapping the stack's ports and volumes to the host:
+
+  ```bash
+  laconic-so --stack proxy-server deploy init --output proxy-server-spec.yml
+  ```
+
+* Edit `network` in spec file to map container ports to same ports in host:
+
+  ```yml
+  ...
+  network:
+    ports:
+      proxy-server:
+        - '4000:4000'
+  ...
+  ```
+
+* Once you've made any needed changes to the spec file, create a deployment from it:
+
+  ```bash
+  laconic-so --stack proxy-server deploy create --spec-file proxy-server-spec.yml --deployment-dir proxy-server-deployment
+  ```
+
+* Inside the deployment directory, open the file `config.env` and set the following env variables:
+
+  ```bash
+  # Whether to run the proxy server (Optional) (Default: true)
+  ENABLE_PROXY=
+
+  # Upstream endpoint
+  # (Eg. https://api.example.org)
+  CERC_PROXY_UPSTREAM=
+
+  # Origin header to be used (Optional)
+  # (Eg. https://app.example.org)
+  CERC_PROXY_ORIGIN_HEADER=
+  ```
+
+## Start the stack
+
+Start the deployment:
+
+```bash
+laconic-so deployment --dir proxy-server-deployment start
+```
+
+* List and check the health status of the container using `docker ps`
+
+* The proxy server will now be listening at http://localhost:4000
+
+## Clean up
+
+To stop the service running in background:
+
+```bash
+laconic-so deployment --dir proxy-server-deployment stop
+```
@@ -0,0 +1,8 @@
+version: "0.1"
+name: proxy-server
+repos:
+  - github.com/cerc-io/watcher-ts@v0.2.78
+containers:
+  - cerc/watcher-ts
+pods:
+  - proxy-server
@@ -0,0 +1,151 @@
+# Self-hosted Uniswap Frontend
+
+Instructions to setup and deploy Uniswap app on Urbit
+
+Build and deploy:
+
+- Urbit
+- Uniswap app
+
+## Setup
+
+Clone required repositories:
+
+```bash
+laconic-so --stack uniswap-urbit-app setup-repositories --pull
+
+# If this throws an error as a result of being already checked out to a branch/tag in a repo, remove the repositories mentioned below and re-run the command
+```
+
+Build the container images:
+
+```bash
+laconic-so --stack uniswap-urbit-app build-containers
+```
+
+## Create a deployment
+
+First, create a spec file for the deployment, which will map the stack's ports and volumes to the host:
+
+```bash
+laconic-so --stack uniswap-urbit-app deploy init --output uniswap-urbit-app-spec.yml
+```
+
+### Ports
+
+Edit `network` in spec file to map container ports to same ports in host
+
+```
+...
+network:
+  ports:
+    urbit-fake-ship:
+      - '8080:80'
+    proxy-server:
+      - '4000:4000'
+    ipfs-glob-host:
+      - '8081:8080'
+      - '5001:5001'
+...
+```
+
+### Data volumes
+
+Container data volumes are bind-mounted to specified paths in the host filesystem.
+The default setup (generated by `laconic-so deploy init`) places the volumes in the `./data` subdirectory of the deployment directory. The default mappings can be customized by editing the "spec" file generated by `laconic-so deploy init`.
+
+---
+
+Once you've made any needed changes to the spec file, create a deployment from it:
+
+```bash
+laconic-so --stack uniswap-urbit-app deploy create --spec-file uniswap-urbit-app-spec.yml --deployment-dir uniswap-urbit-app-deployment
+```
+
+## Set env variables
+
+Inside the deployment directory, open the file `config.env` and set the following env variables:
+
+  ```bash
+  # External RPC endpoints
+  # https://docs.infura.io/getting-started#2-create-an-api-key
+  CERC_INFURA_KEY=
+
+  # Uniswap API GQL Endpoint
+  # Set this to GQL proxy server endpoint for uniswap app
+  # (Eg. http://localhost:4000/v1/graphql)
+  # (Eg. https://abc.xyz.com/v1/graphql)
+  CERC_UNISWAP_GQL=
+
+  # Optional
+
+  # Whether to run the proxy GQL server
+  # (Disable only if proxy not required to be run) (Default: true)
+  ENABLE_PROXY=
+
+  # Proxy server configuration
+  # Used only if proxy is enabled
+
+  # Upstream API URL
+  # (Eg. https://api.example.org)
+  CERC_PROXY_UPSTREAM=https://api.uniswap.org
+
+  # Origin header to be used in the proxy
+  # (Eg. https://app.example.org)
+  CERC_PROXY_ORIGIN_HEADER=https://app.uniswap.org
+
+  # IPFS configuration
+
+  # IFPS endpoint to host the glob file on
+  # (Default: http://ipfs-glob-host:5001 pointing to in-stack IPFS node)
+  CERC_IPFS_GLOB_HOST_ENDPOINT=
+
+  # IFPS endpoint to fetch the glob file from
+  # (Default: http://ipfs-glob-host:8080 pointing to in-stack IPFS node)
+  CERC_IPFS_SERVER_ENDPOINT=
+  ```
+
+## Start the stack
+
+Start the deployment:
+
+```bash
+laconic-so deployment --dir uniswap-urbit-app-deployment start
+```
+
+* List and check the health status of all the containers using `docker ps` and wait for them to be `healthy`
+
+* Run the following to get login password for Urbit web interface:
+
+  ```bash
+  laconic-so deployment --dir uniswap-urbit-app-deployment exec urbit-fake-ship "curl -s --data '{\"source\":{\"dojo\":\"+code\"},\"sink\":{\"stdout\":null}}' http://localhost:12321"
+
+  # Expected output: "<PASSWORD>\n"%
+  ```
+
+* Open the Urbit web UI at http://localhost:8080 and use the `PASSWORD` from previous step to login
+
+* The uniswap app is not available when starting stack for the first time. Check `urbit-fake-ship` logs to see that app has installed
+  ```
+  laconic-so deployment --dir uniswap-urbit-app-deployment logs -f
+
+  # Expected output:
+  # laconic-3ccf7ee79bdae874-urbit-fake-ship-1    | docket: fetching %http glob for %uniswap desk
+  # laconic-3ccf7ee79bdae874-urbit-fake-ship-1    | ">="">="Uniswap app installed
+  ```
+
+* The uniswap app will be now visible at http://localhost:8080
+
+## Clean up
+
+To stop all uniswap-urbit-app services running in the background, while preserving data:
+
+```bash
+laconic-so deployment --dir uniswap-urbit-app-deployment stop
+```
+
+To stop all uniswap-urbit-app services and also delete data:
+
+```bash
+laconic-so deployment --dir uniswap-urbit-app-deployment stop --delete-volumes
+```
@@ -0,0 +1,13 @@
+version: "0.1"
+name: uniswap-urbit-app
+repos:
+  - github.com/cerc-io/uniswap-interface@laconic # TODO: Use release
+  - github.com/cerc-io/watcher-ts@v0.2.78
+containers:
+  - cerc/uniswap-interface
+  - cerc/watcher-ts
+  - cerc/urbit-globs-host
+pods:
+  - uniswap-interface
+  - proxy-server
+  - uniswap-urbit
@@ -0,0 +1 @@
+# Template stack for webapp deployments
@@ -0,0 +1,7 @@
+version: "1.0"
+name: test
+description: "Webapp deployment stack"
+containers:
+  - cerc/webapp-template-container
+pods:
+  - webapp-template
@@ -40,6 +40,13 @@ class DockerDeployer(Deployer):
        except DockerException as e:
            raise DeployerException(e)

+    def status(self):
+        try:
+            for p in self.docker.compose.ps():
+                print(f"{p.name}\t{p.state.status}")
+        except DockerException as e:
+            raise DeployerException(e)
+
    def ps(self):
        try:
            return self.docker.compose.ps()
@@ -64,10 +71,10 @@ class DockerDeployer(Deployer):
        except DockerException as e:
            raise DeployerException(e)

-    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, detach=False):
+    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, ports=[], detach=False):
        try:
            return self.docker.run(image=image, command=command, user=user, volumes=volumes,
-                                   entrypoint=entrypoint, envs=env, detach=detach, publish_all=True)
+                                   entrypoint=entrypoint, envs=env, detach=detach, publish=ports, publish_all=len(ports) == 0)
        except DockerException as e:
            raise DeployerException(e)

@@ -24,6 +24,8 @@ from importlib import resources
 import subprocess
 import click
 from pathlib import Path
+from stack_orchestrator import constants
+from stack_orchestrator.opts import opts
 from stack_orchestrator.util import include_exclude_check, get_parsed_stack_config, global_options2, get_dev_root_path
 from stack_orchestrator.deploy.deployer import Deployer, DeployerException
 from stack_orchestrator.deploy.deployer_factory import getDeployer
@@ -70,6 +72,9 @@ def create_deploy_context(
        cluster,
        env_file,
        deploy_to) -> DeployCommandContext:
+    # Extract the cluster name from the deployment, if we have one
+    if deployment_context and cluster is None:
+        cluster = deployment_context.get_cluster_id()
    cluster_context = _make_cluster_context(global_context, stack, include, exclude, cluster, env_file)
    deployer = getDeployer(deploy_to, deployment_context, compose_files=cluster_context.compose_files,
                           compose_project_name=cluster_context.cluster,
@@ -107,6 +112,14 @@ def down_operation(ctx, delete_volumes, extra_args_list):
        ctx.obj.deployer.down(timeout=timeout_arg, volumes=delete_volumes)


+def status_operation(ctx):
+    global_context = ctx.parent.parent.obj
+    if not global_context.dry_run:
+        if global_context.verbose:
+            print("Running compose status")
+        ctx.obj.deployer.status()
+
+
 def ps_operation(ctx):
    global_context = ctx.parent.parent.obj
    if not global_context.dry_run:
@@ -253,6 +266,22 @@ def _make_runtime_env(ctx):
    return container_exec_env


+def _make_default_cluster_name(deployment, compose_dir, stack, include, exclude):
+    # Create default unique, stable cluster name from confile file path and stack name if provided
+    if deployment:
+        path = os.path.realpath(os.path.abspath(compose_dir))
+    else:
+        path = "internal"
+    unique_cluster_descriptor = f"{path},{stack},{include},{exclude}"
+    if opts.o.debug:
+        print(f"pre-hash descriptor: {unique_cluster_descriptor}")
+    hash = hashlib.md5(unique_cluster_descriptor.encode()).hexdigest()[:16]
+    cluster = f"{constants.cluster_name_prefix}{hash}"
+    if opts.o.debug:
+        print(f"Using cluster name: {cluster}")
+    return cluster
+
+
 # stack has to be either PathLike pointing to a stack yml file, or a string with the name of a known stack
 def _make_cluster_context(ctx, stack, include, exclude, cluster, env_file):

@@ -270,16 +299,9 @@ def _make_cluster_context(ctx, stack, include, exclude, cluster, env_file):
        compose_dir = Path(__file__).absolute().parent.parent.joinpath("data", "compose")

    if cluster is None:
-        # Create default unique, stable cluster name from confile file path and stack name if provided
-        # TODO: change this to the config file path
-        path = os.path.realpath(sys.argv[0])
-        unique_cluster_descriptor = f"{path},{stack},{include},{exclude}"
-        if ctx.debug:
-            print(f"pre-hash descriptor: {unique_cluster_descriptor}")
-        hash = hashlib.md5(unique_cluster_descriptor.encode()).hexdigest()
-        cluster = f"laconic-{hash}"
-        if ctx.verbose:
-            print(f"Using cluster name: {cluster}")
+        cluster = _make_default_cluster_name(deployment, compose_dir, stack, include, exclude)
+    else:
+        _make_default_cluster_name(deployment, compose_dir, stack, include, exclude)

    # See: https://stackoverflow.com/a/20885799/1701505
    from stack_orchestrator import data
@@ -31,6 +31,10 @@ class Deployer(ABC):
    def ps(self):
        pass

+    @abstractmethod
+    def status(self):
+        pass
+
    @abstractmethod
    def port(self, service, private_port):
        pass
@@ -44,7 +48,7 @@ class Deployer(ABC):
        pass

    @abstractmethod
-    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, detach=False):
+    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, ports=[], detach=False):
        pass


@@ -18,7 +18,7 @@ from pathlib import Path
 import sys
 from stack_orchestrator import constants
 from stack_orchestrator.deploy.images import push_images_operation
-from stack_orchestrator.deploy.deploy import up_operation, down_operation, ps_operation, port_operation
+from stack_orchestrator.deploy.deploy import up_operation, down_operation, ps_operation, port_operation, status_operation
 from stack_orchestrator.deploy.deploy import exec_operation, logs_operation, create_deploy_context
 from stack_orchestrator.deploy.deploy_types import DeployCommandContext
 from stack_orchestrator.deploy.deployment_context import DeploymentContext
@@ -52,7 +52,7 @@ def make_deploy_context(ctx) -> DeployCommandContext:
    context: DeploymentContext = ctx.obj
    stack_file_path = context.get_stack_file()
    env_file = context.get_env_file()
-    cluster_name = context.get_cluster_name()
+    cluster_name = context.get_cluster_id()
    if constants.deploy_to_key in context.spec.obj:
        deployment_type = context.spec.obj[constants.deploy_to_key]
    else:
@@ -147,4 +147,5 @@ def logs(ctx, tail, follow, extra_args):
@command.command()
@click.pass_context
 def status(ctx):
-    print(f"Context: {ctx.parent.obj}")
+    ctx.obj = make_deploy_context(ctx)
+    status_operation(ctx)
@@ -14,29 +14,39 @@
 # 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 hashlib
+import os
 from pathlib import Path

+from stack_orchestrator import constants
+from stack_orchestrator.util import get_yaml
 from stack_orchestrator.deploy.stack import Stack
 from stack_orchestrator.deploy.spec import Spec


 class DeploymentContext:
    deployment_dir: Path
+    id: str
    spec: Spec
    stack: Stack

    def get_stack_file(self):
-        return self.deployment_dir.joinpath("stack.yml")
+        return self.deployment_dir.joinpath(constants.stack_file_name)

    def get_spec_file(self):
-        return self.deployment_dir.joinpath("spec.yml")
+        return self.deployment_dir.joinpath(constants.spec_file_name)

    def get_env_file(self):
-        return self.deployment_dir.joinpath("config.env")
+        return self.deployment_dir.joinpath(constants.config_file_name)

-    # TODO: implement me
-    def get_cluster_name(self):
-        return None
+    def get_deployment_file(self):
+        return self.deployment_dir.joinpath(constants.deployment_file_name)
+
+    def get_compose_dir(self):
+        return self.deployment_dir.joinpath(constants.compose_dir_name)
+
+    def get_cluster_id(self):
+        return self.id

    def init(self, dir):
        self.deployment_dir = dir
@@ -44,3 +54,16 @@ class DeploymentContext:
        self.spec.init_from_file(self.get_spec_file())
        self.stack = Stack(self.spec.obj["stack"])
        self.stack.init_from_file(self.get_stack_file())
+        deployment_file_path = self.get_deployment_file()
+        if deployment_file_path.exists():
+            with deployment_file_path:
+                obj = get_yaml().load(open(deployment_file_path, "r"))
+                self.id = obj[constants.cluster_id_key]
+        # Handle the case of a legacy deployment with no file
+        # Code below is intended to match the output from _make_default_cluster_name()
+        # TODO: remove when we no longer need to support legacy deployments
+        else:
+            path = os.path.realpath(os.path.abspath(self.get_compose_dir()))
+            unique_cluster_descriptor = f"{path},{self.get_stack_file()},None,None"
+            hash = hashlib.md5(unique_cluster_descriptor.encode()).hexdigest()[:16]
+            self.id = f"{constants.cluster_name_prefix}{hash}"
@@ -20,11 +20,13 @@ from pathlib import Path
 from typing import List
 import random
 from shutil import copy, copyfile, copytree
+from secrets import token_hex
 import sys
 from stack_orchestrator import constants
+from stack_orchestrator.opts import opts
 from stack_orchestrator.util import (get_stack_file_path, get_parsed_deployment_spec, get_parsed_stack_config,
                                     global_options, get_yaml, get_pod_list, get_pod_file_path, pod_has_scripts,
-                                     get_pod_script_paths, get_plugin_code_paths, error_exit)
+                                     get_pod_script_paths, get_plugin_code_paths, error_exit, env_var_map_from_file)
 from stack_orchestrator.deploy.deploy_types import LaconicStackSetupCommand
 from stack_orchestrator.deploy.deployer_factory import getDeployerConfigGenerator
 from stack_orchestrator.deploy.deployment_context import DeploymentContext
@@ -103,8 +105,8 @@ def _fixup_pod_file(pod, spec, compose_dir):
                                       }
                    pod["volumes"][volume] = new_volume_spec
    # Fix up ports
-    if "ports" in spec:
-        spec_ports = spec["ports"]
+    if "network" in spec and "ports" in spec["network"]:
+        spec_ports = spec["network"]["ports"]
        for container_name, container_ports in spec_ports.items():
            if container_name in pod["services"]:
                pod["services"][container_name]["ports"] = container_ports
@@ -243,12 +245,13 @@ def _parse_config_variables(variable_values: str):
                variable_name = variable_value_pair[0]
                variable_value = variable_value_pair[1]
                result_values[variable_name] = variable_value
-            result = {"config": result_values}
+            result = result_values
    return result


@click.command()
@click.option("--config", help="Provide config variables for the deployment")
+@click.option("--config-file", help="Provide config variables in a file for the deployment")
@click.option("--kube-config", help="Provide a config file for a k8s deployment")
@click.option("--image-registry", help="Provide a container image registry url for this k8s cluster")
@click.option("--output", required=True, help="Write yaml spec file here")
@@ -256,14 +259,32 @@ def _parse_config_variables(variable_values: str):
              help="Map ports to the host as one of: any-variable-random (default), "
              "localhost-same, any-same, localhost-fixed-random, any-fixed-random")
@click.pass_context
-def init(ctx, config, kube_config, image_registry, output, map_ports_to_host):
-    yaml = get_yaml()
+def init(ctx, config, config_file, kube_config, image_registry, output, map_ports_to_host):
    stack = global_options(ctx).stack
-    debug = global_options(ctx).debug
    deployer_type = ctx.obj.deployer.type
-    default_spec_file_content = call_stack_deploy_init(ctx.obj)
+    deploy_command_context = ctx.obj
+    return init_operation(
+        deploy_command_context,
+        stack, deployer_type,
+        config, config_file,
+        kube_config,
+        image_registry,
+        output,
+        map_ports_to_host)
+
+
+# The init command's implementation is in a separate function so that we can
+# call it from other commands, bypassing the click decoration stuff
+def init_operation(deploy_command_context, stack, deployer_type, config,
+                   config_file, kube_config, image_registry, output, map_ports_to_host):
+
+    default_spec_file_content = call_stack_deploy_init(deploy_command_context)
    spec_file_content = {"stack": stack, constants.deploy_to_key: deployer_type}
    if deployer_type == "k8s":
+        if kube_config is None:
+            error_exit("--kube-config must be supplied with --deploy-to k8s")
+        if image_registry is None:
+            error_exit("--image-registry must be supplied with --deploy-to k8s")
        spec_file_content.update({constants.kube_config_key: kube_config})
        spec_file_content.update({constants.image_resigtry_key: image_registry})
    else:
@@ -275,17 +296,25 @@ def init(ctx, config, kube_config, image_registry, output, map_ports_to_host):
    if default_spec_file_content:
        spec_file_content.update(default_spec_file_content)
    config_variables = _parse_config_variables(config)
+    # Implement merge, since update() overwrites
    if config_variables:
-        # Implement merge, since update() overwrites
        orig_config = spec_file_content.get("config", {})
-        new_config = config_variables["config"]
+        new_config = config_variables
        merged_config = {**new_config, **orig_config}
        spec_file_content.update({"config": merged_config})
-    if debug:
-        print(f"Creating spec file for stack: {stack} with content: {spec_file_content}")
+    if config_file:
+        config_file_path = Path(config_file)
+        if not config_file_path.exists():
+            error_exit(f"config file: {config_file} does not exist")
+        config_file_variables = env_var_map_from_file(config_file_path)
+        if config_file_variables:
+            orig_config = spec_file_content.get("config", {})
+            new_config = config_file_variables
+            merged_config = {**new_config, **orig_config}
+            spec_file_content.update({"config": merged_config})

    ports = _get_mapped_ports(stack, map_ports_to_host)
-    spec_file_content["ports"] = ports
+    spec_file_content.update({"network": {"ports": ports}})

    named_volumes = _get_named_volumes(stack)
    if named_volumes:
@@ -294,8 +323,11 @@ def init(ctx, config, kube_config, image_registry, output, map_ports_to_host):
            volume_descriptors[named_volume] = f"./data/{named_volume}"
        spec_file_content["volumes"] = volume_descriptors

+    if opts.o.debug:
+        print(f"Creating spec file for stack: {stack} with content: {spec_file_content}")
+
    with open(output, "w") as output_file:
-        yaml.dump(spec_file_content, output_file)
+        get_yaml().dump(spec_file_content, output_file)


 def _write_config_file(spec_file: Path, config_env_file: Path):
@@ -321,6 +353,13 @@ def _copy_files_to_directory(file_paths: List[Path], directory: Path):
        copy(path, os.path.join(directory, os.path.basename(path)))


+def _create_deployment_file(deployment_dir: Path):
+    deployment_file_path = deployment_dir.joinpath(constants.deployment_file_name)
+    cluster = f"{constants.cluster_name_prefix}{token_hex(8)}"
+    with open(deployment_file_path, "w") as output_file:
+        output_file.write(f"{constants.cluster_id_key}: {cluster}\n")
+
+
@click.command()
@click.option("--spec-file", required=True, help="Spec file to use to create this deployment")
@click.option("--deployment-dir", help="Create deployment files in this directory")
@@ -329,12 +368,19 @@ def _copy_files_to_directory(file_paths: List[Path], directory: Path):
@click.option("--initial-peers", help="Initial set of persistent peers")
@click.pass_context
 def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
+    deployment_command_context = ctx.obj
+    return create_operation(deployment_command_context, spec_file, deployment_dir, network_dir, initial_peers)
+
+
+# The init command's implementation is in a separate function so that we can
+# call it from other commands, bypassing the click decoration stuff
+def create_operation(deployment_command_context, spec_file, deployment_dir, network_dir, initial_peers):
    parsed_spec = get_parsed_deployment_spec(spec_file)
    stack_name = parsed_spec["stack"]
    deployment_type = parsed_spec[constants.deploy_to_key]
    stack_file = get_stack_file_path(stack_name)
    parsed_stack = get_parsed_stack_config(stack_name)
-    if global_options(ctx).debug:
+    if opts.o.debug:
        print(f"parsed spec: {parsed_spec}")
    if deployment_dir is None:
        deployment_dir_path = _make_default_deployment_dir()
@@ -344,10 +390,11 @@ def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
        error_exit(f"{deployment_dir_path} already exists")
    os.mkdir(deployment_dir_path)
    # Copy spec file and the stack file into the deployment dir
-    copyfile(spec_file, deployment_dir_path.joinpath("spec.yml"))
+    copyfile(spec_file, deployment_dir_path.joinpath(constants.spec_file_name))
    copyfile(stack_file, deployment_dir_path.joinpath(os.path.basename(stack_file)))
+    _create_deployment_file(deployment_dir_path)
    # Copy any config varibles from the spec file into an env file suitable for compose
-    _write_config_file(spec_file, deployment_dir_path.joinpath("config.env"))
+    _write_config_file(spec_file, deployment_dir_path.joinpath(constants.config_file_name))
    # Copy any k8s config file into the deployment dir
    if deployment_type == "k8s":
        _write_kube_config_file(Path(parsed_spec[constants.kube_config_key]),
@@ -366,7 +413,7 @@ def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
        extra_config_dirs = _find_extra_config_dirs(parsed_pod_file, pod)
        destination_pod_dir = destination_pods_dir.joinpath(pod)
        os.mkdir(destination_pod_dir)
-        if global_options(ctx).debug:
+        if opts.o.debug:
            print(f"extra config dirs: {extra_config_dirs}")
        _fixup_pod_file(parsed_pod_file, parsed_spec, destination_compose_dir)
        with open(destination_compose_dir.joinpath("docker-compose-%s.yml" % pod), "w") as output_file:
@@ -390,7 +437,6 @@ def create(ctx, spec_file, deployment_dir, network_dir, initial_peers):
    # Delegate to the stack's Python code
    # The deploy create command doesn't require a --stack argument so we need to insert the
    # stack member here.
-    deployment_command_context = ctx.obj
    deployment_command_context.stack = stack_name
    deployment_context = DeploymentContext()
    deployment_context.init(deployment_dir_path)
@@ -17,34 +17,117 @@ from kubernetes import client
 from typing import Any, List, Set

 from stack_orchestrator.opts import opts
+from stack_orchestrator.util import env_var_map_from_file
 from stack_orchestrator.deploy.k8s.helpers import named_volumes_from_pod_files, volume_mounts_for_service, volumes_for_pod_files
 from stack_orchestrator.deploy.k8s.helpers import get_node_pv_mount_path
-from stack_orchestrator.deploy.k8s.helpers import env_var_map_from_file, envs_from_environment_variables_map
+from stack_orchestrator.deploy.k8s.helpers import envs_from_environment_variables_map
 from stack_orchestrator.deploy.deploy_util import parsed_pod_files_map_from_file_names, images_for_deployment
 from stack_orchestrator.deploy.deploy_types import DeployEnvVars
+from stack_orchestrator.deploy.spec import Spec
 from stack_orchestrator.deploy.images import remote_tag_for_image


 class ClusterInfo:
    parsed_pod_yaml_map: Any
    image_set: Set[str] = set()
-    app_name: str = "test-app"
-    deployment_name: str = "test-deployment"
+    app_name: str
    environment_variables: DeployEnvVars
-    remote_image_repo: str
+    spec: Spec

    def __init__(self) -> None:
        pass

-    def int(self, pod_files: List[str], compose_env_file, remote_image_repo):
+    def int(self, pod_files: List[str], compose_env_file, deployment_name, spec: Spec):
        self.parsed_pod_yaml_map = parsed_pod_files_map_from_file_names(pod_files)
        # Find the set of images in the pods
        self.image_set = images_for_deployment(pod_files)
        self.environment_variables = DeployEnvVars(env_var_map_from_file(compose_env_file))
-        self.remote_image_repo = remote_image_repo
+        self.app_name = deployment_name
+        self.spec = spec
        if (opts.o.debug):
            print(f"Env vars: {self.environment_variables.map}")

+    def get_ingress(self):
+        # No ingress for a deployment that has no http-proxy defined, for now
+        http_proxy_info_list = self.spec.get_http_proxy()
+        ingress = None
+        if http_proxy_info_list:
+            # TODO: handle multiple definitions
+            http_proxy_info = http_proxy_info_list[0]
+            if opts.o.debug:
+                print(f"http-proxy: {http_proxy_info}")
+            # TODO: good enough parsing for webapp deployment for now
+            host_name = http_proxy_info["host-name"]
+            rules = []
+            tls = [client.V1IngressTLS(
+                hosts=[host_name],
+                secret_name=f"{self.app_name}-tls"
+            )]
+            paths = []
+            for route in http_proxy_info["routes"]:
+                path = route["path"]
+                proxy_to = route["proxy-to"]
+                if opts.o.debug:
+                    print(f"proxy config: {path} -> {proxy_to}")
+                # proxy_to has the form <service>:<port>
+                proxy_to_port = int(proxy_to.split(":")[1])
+                paths.append(client.V1HTTPIngressPath(
+                    path_type="Prefix",
+                    path=path,
+                    backend=client.V1IngressBackend(
+                        service=client.V1IngressServiceBackend(
+                            # TODO: this looks wrong
+                            name=f"{self.app_name}-service",
+                            # TODO: pull port number from the service
+                            port=client.V1ServiceBackendPort(number=proxy_to_port)
+                        )
+                    )
+                ))
+            rules.append(client.V1IngressRule(
+                host=host_name,
+                http=client.V1HTTPIngressRuleValue(
+                    paths=paths
+                )
+            ))
+            spec = client.V1IngressSpec(
+                tls=tls,
+                rules=rules
+            )
+            ingress = client.V1Ingress(
+                metadata=client.V1ObjectMeta(
+                    name=f"{self.app_name}-ingress",
+                    annotations={
+                        "kubernetes.io/ingress.class": "nginx",
+                        "cert-manager.io/cluster-issuer": "letsencrypt-prod"
+                    }
+                ),
+                spec=spec
+            )
+        return ingress
+
+    # TODO: suppoprt multiple services
+    def get_service(self):
+        for pod_name in self.parsed_pod_yaml_map:
+            pod = self.parsed_pod_yaml_map[pod_name]
+            services = pod["services"]
+            for service_name in services:
+                service_info = services[service_name]
+                port = int(service_info["ports"][0])
+                if opts.o.debug:
+                    print(f"service port: {port}")
+        service = client.V1Service(
+            metadata=client.V1ObjectMeta(name=f"{self.app_name}-service"),
+            spec=client.V1ServiceSpec(
+                type="ClusterIP",
+                ports=[client.V1ServicePort(
+                    port=port,
+                    target_port=port
+                )],
+                selector={"app": self.app_name}
+            )
+        )
+        return service
+
    def get_pvcs(self):
        result = []
        volumes = named_volumes_from_pod_files(self.parsed_pod_yaml_map)
@@ -95,14 +178,19 @@ class ClusterInfo:
                container_name = service_name
                service_info = services[service_name]
                image = service_info["image"]
+                port = int(service_info["ports"][0])
+                if opts.o.debug:
+                    print(f"image: {image}")
+                    print(f"service port: {port}")
                # Re-write the image tag for remote deployment
-                image_to_use = remote_tag_for_image(image, self.remote_image_repo) if self.remote_image_repo is not None else image
+                image_to_use = remote_tag_for_image(
+                    image, self.spec.get_image_registry()) if self.spec.get_image_registry() is not None else image
                volume_mounts = volume_mounts_for_service(self.parsed_pod_yaml_map, service_name)
                container = client.V1Container(
                    name=container_name,
                    image=image_to_use,
                    env=envs_from_environment_variables_map(self.environment_variables.map),
-                    ports=[client.V1ContainerPort(container_port=80)],
+                    ports=[client.V1ContainerPort(container_port=port)],
                    volume_mounts=volume_mounts,
                    resources=client.V1ResourceRequirements(
                        requests={"cpu": "100m", "memory": "200Mi"},
@@ -123,7 +211,7 @@ class ClusterInfo:
        deployment = client.V1Deployment(
            api_version="apps/v1",
            kind="Deployment",
-            metadata=client.V1ObjectMeta(name=self.deployment_name),
+            metadata=client.V1ObjectMeta(name=f"{self.app_name}-deployment"),
            spec=spec,
        )
        return deployment
@@ -23,6 +23,21 @@ from stack_orchestrator.deploy.k8s.helpers import pods_in_deployment, log_stream
 from stack_orchestrator.deploy.k8s.cluster_info import ClusterInfo
 from stack_orchestrator.opts import opts
 from stack_orchestrator.deploy.deployment_context import DeploymentContext
+from stack_orchestrator.util import error_exit
+
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+def _check_delete_exception(e: client.exceptions.ApiException):
+    if e.status == 404:
+        if opts.o.debug:
+            print("Failed to delete object, continuing")
+    else:
+        error_exit(f"k8s api error: {e}")


 class K8sDeployer(Deployer):
@@ -30,9 +45,10 @@ class K8sDeployer(Deployer):
    type: str
    core_api: client.CoreV1Api
    apps_api: client.AppsV1Api
+    networking_api: client.NetworkingV1Api
    k8s_namespace: str = "default"
    kind_cluster_name: str
-    cluster_info : ClusterInfo
+    cluster_info: ClusterInfo
    deployment_dir: Path
    deployment_context: DeploymentContext

@@ -45,7 +61,7 @@ class K8sDeployer(Deployer):
        self.deployment_context = deployment_context
        self.kind_cluster_name = compose_project_name
        self.cluster_info = ClusterInfo()
-        self.cluster_info.int(compose_files, compose_env_file, deployment_context.spec.obj[constants.image_resigtry_key])
+        self.cluster_info.int(compose_files, compose_env_file, compose_project_name, deployment_context.spec)
        if (opts.o.debug):
            print(f"Deployment dir: {deployment_context.deployment_dir}")
            print(f"Compose files: {compose_files}")
@@ -60,9 +76,12 @@ class K8sDeployer(Deployer):
            # Get the config file and pass to load_kube_config()
            config.load_kube_config(config_file=self.deployment_dir.joinpath(constants.kube_config_filename).as_posix())
        self.core_api = client.CoreV1Api()
+        self.networking_api = client.NetworkingV1Api()
        self.apps_api = client.AppsV1Api()
+        self.custom_obj_api = client.CustomObjectsApi()

    def up(self, detach, services):
+
        if self.is_kind():
            # Create the kind cluster
            create_cluster(self.kind_cluster_name, self.deployment_dir.joinpath(constants.kind_config_filename))
@@ -102,6 +121,28 @@ class K8sDeployer(Deployer):
            print(f"{deployment_resp.metadata.namespace} {deployment_resp.metadata.name} \
                  {deployment_resp.metadata.generation} {deployment_resp.spec.template.spec.containers[0].image}")

+        service: client.V1Service = self.cluster_info.get_service()
+        service_resp = self.core_api.create_namespaced_service(
+            namespace=self.k8s_namespace,
+            body=service
+        )
+        if opts.o.debug:
+            print("Service created:")
+            print(f"{service_resp}")
+
+        # TODO: disable ingress for kind
+        ingress: client.V1Ingress = self.cluster_info.get_ingress()
+
+        if opts.o.debug:
+            print(f"Sending this ingress: {ingress}")
+        ingress_resp = self.networking_api.create_namespaced_ingress(
+            namespace=self.k8s_namespace,
+            body=ingress
+        )
+        if opts.o.debug:
+            print("Ingress created:")
+            print(f"{ingress_resp}")
+
    def down(self, timeout, volumes):
        self.connect_api()
        # Delete the k8s objects
@@ -110,41 +151,140 @@ class K8sDeployer(Deployer):
        for pv in pvs:
            if opts.o.debug:
                print(f"Deleting this pv: {pv}")
-            pv_resp = self.core_api.delete_persistent_volume(name=pv.metadata.name)
-            if opts.o.debug:
-                print("PV deleted:")
-                print(f"{pv_resp}")
+            try:
+                pv_resp = self.core_api.delete_persistent_volume(name=pv.metadata.name)
+                if opts.o.debug:
+                    print("PV deleted:")
+                    print(f"{pv_resp}")
+            except client.exceptions.ApiException as e:
+                _check_delete_exception(e)

        # Figure out the PVCs for this deployment
        pvcs = self.cluster_info.get_pvcs()
        for pvc in pvcs:
            if opts.o.debug:
                print(f"Deleting this pvc: {pvc}")
-            pvc_resp = self.core_api.delete_namespaced_persistent_volume_claim(name=pvc.metadata.name, namespace=self.k8s_namespace)
-            if opts.o.debug:
-                print("PVCs deleted:")
-                print(f"{pvc_resp}")
-        # Process compose files into a Deployment
+            try:
+                pvc_resp = self.core_api.delete_namespaced_persistent_volume_claim(
+                    name=pvc.metadata.name, namespace=self.k8s_namespace
+                )
+                if opts.o.debug:
+                    print("PVCs deleted:")
+                    print(f"{pvc_resp}")
+            except client.exceptions.ApiException as e:
+                _check_delete_exception(e)
        deployment = self.cluster_info.get_deployment()
-        # Create the k8s objects
        if opts.o.debug:
            print(f"Deleting this deployment: {deployment}")
-        self.apps_api.delete_namespaced_deployment(
-            name=deployment.metadata.name, namespace=self.k8s_namespace
-        )
+        try:
+            self.apps_api.delete_namespaced_deployment(
+                name=deployment.metadata.name, namespace=self.k8s_namespace
+            )
+        except client.exceptions.ApiException as e:
+            _check_delete_exception(e)
+
+        service: client.V1Service = self.cluster_info.get_service()
+        if opts.o.debug:
+            print(f"Deleting service: {service}")
+        try:
+            self.core_api.delete_namespaced_service(
+                namespace=self.k8s_namespace,
+                name=service.metadata.name
+            )
+        except client.exceptions.ApiException as e:
+            _check_delete_exception(e)
+
+        # TODO: disable ingress for kind
+        ingress: client.V1Ingress = self.cluster_info.get_ingress()
+        if opts.o.debug:
+            print(f"Deleting this ingress: {ingress}")
+        try:
+            self.networking_api.delete_namespaced_ingress(
+                name=ingress.metadata.name, namespace=self.k8s_namespace
+            )
+        except client.exceptions.ApiException as e:
+            _check_delete_exception(e)
+
        if self.is_kind():
            # Destroy the kind cluster
            destroy_cluster(self.kind_cluster_name)

-    def ps(self):
+    def status(self):
        self.connect_api()
        # Call whatever API we need to get the running container list
-        ret = self.core_api.list_pod_for_all_namespaces(watch=False)
-        if ret.items:
-            for i in ret.items:
-                print("%s\t%s\t%s" % (i.status.pod_ip, i.metadata.namespace, i.metadata.name))
-        ret = self.core_api.list_node(pretty=True, watch=False)
-        return []
+        all_pods = self.core_api.list_pod_for_all_namespaces(watch=False)
+        pods = []
+
+        if all_pods.items:
+            for p in all_pods.items:
+                if self.cluster_info.app_name in p.metadata.name:
+                    pods.append(p)
+
+        if not pods:
+            return
+
+        hostname = "?"
+        ip = "?"
+        tls = "?"
+        try:
+            ingress = self.networking_api.read_namespaced_ingress(namespace=self.k8s_namespace,
+                                                                  name=self.cluster_info.get_ingress().metadata.name)
+
+            cert = self.custom_obj_api.get_namespaced_custom_object(
+                group="cert-manager.io",
+                version="v1",
+                namespace=self.k8s_namespace,
+                plural="certificates",
+                name=ingress.spec.tls[0].secret_name
+            )
+
+            hostname = ingress.spec.tls[0].hosts[0]
+            ip = ingress.status.load_balancer.ingress[0].ip
+            tls = "notBefore: %s, notAfter: %s" % (cert["status"]["notBefore"], cert["status"]["notAfter"])
+        except:  # noqa: E722
+            pass
+
+        print("Ingress:")
+        print("\tHostname:", hostname)
+        print("\tIP:", ip)
+        print("\tTLS:", tls)
+        print("")
+        print("Pods:")
+
+        for p in pods:
+            if p.metadata.deletion_timestamp:
+                print(f"\t{p.metadata.namespace}/{p.metadata.name}: Terminating ({p.metadata.deletion_timestamp})")
+            else:
+                print(f"\t{p.metadata.namespace}/{p.metadata.name}: Running ({p.metadata.creation_timestamp})")
+
+    def ps(self):
+        self.connect_api()
+        pods = self.core_api.list_pod_for_all_namespaces(watch=False)
+
+        ret = []
+
+        for p in pods.items:
+            if self.cluster_info.app_name in p.metadata.name:
+                pod_ip = p.status.pod_ip
+                ports = AttrDict()
+                for c in p.spec.containers:
+                    if c.ports:
+                        for prt in c.ports:
+                            ports[str(prt.container_port)] = [AttrDict({
+                                "HostIp": pod_ip,
+                                "HostPort": prt.container_port
+                            })]
+
+                ret.append(AttrDict({
+                    "id": f"{p.metadata.namespace}/{p.metadata.name}",
+                    "name": p.metadata.name,
+                    "namespace": p.metadata.namespace,
+                    "network_settings": AttrDict({
+                        "ports": ports
+                    })
+                }))
+
+        return ret

    def port(self, service, private_port):
        # Since we handle the port mapping, need to figure out where this comes from
@@ -164,7 +304,7 @@ class K8sDeployer(Deployer):
        log_data = self.core_api.read_namespaced_pod_log(k8s_pod_name, namespace="default", container="test")
        return log_stream_from_string(log_data)

-    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, detach=False):
+    def run(self, image: str, command=None, user=None, volumes=None, entrypoint=None, env={}, ports=[], detach=False):
        # We need to figure out how to do this -- check why we're being called first
        pass

@@ -14,7 +14,6 @@
 # along with this program.  If not, see <http:#www.gnu.org/licenses/>.

 from kubernetes import client
-from dotenv import dotenv_values
 import os
 from pathlib import Path
 import subprocess
@@ -224,7 +223,3 @@ def generate_kind_config(deployment_dir: Path):
        f"{port_mappings_yml}\n"
        f"{mounts_yml}\n"
    )
-
-
-def env_var_map_from_file(file: Path) -> Mapping[str, str]:
-    return dotenv_values(file)
@@ -16,6 +16,7 @@
 from pathlib import Path
 import typing
 from stack_orchestrator.util import get_yaml
+from stack_orchestrator import constants


 class Spec:
@@ -28,3 +29,14 @@ class Spec:
    def init_from_file(self, file_path: Path):
        with file_path:
            self.obj = get_yaml().load(open(file_path, "r"))
+
+    def get_image_registry(self):
+        return (self.obj[constants.image_resigtry_key]
+                if self.obj and constants.image_resigtry_key in self.obj
+                else None)
+
+    def get_http_proxy(self):
+        return (self.obj[constants.network_key][constants.http_proxy_key]
+                if self.obj and constants.network_key in self.obj
+                and constants.http_proxy_key in self.obj[constants.network_key]
+                else None)
@@ -0,0 +1,118 @@
+# 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/>.
+
+import click
+import os
+from pathlib import Path
+from urllib.parse import urlparse
+from tempfile import NamedTemporaryFile
+
+from stack_orchestrator.util import error_exit, global_options2
+from stack_orchestrator.deploy.deployment_create import init_operation, create_operation
+from stack_orchestrator.deploy.deploy import create_deploy_context
+from stack_orchestrator.deploy.deploy_types import DeployCommandContext
+
+
+def _fixup_container_tag(deployment_dir: str, image: str):
+    deployment_dir_path = Path(deployment_dir)
+    compose_file = deployment_dir_path.joinpath("compose", "docker-compose-webapp-template.yml")
+    # replace "cerc/webapp-container:local" in the file with our image tag
+    with open(compose_file) as rfile:
+        contents = rfile.read()
+        contents = contents.replace("cerc/webapp-container:local", image)
+    with open(compose_file, "w") as wfile:
+        wfile.write(contents)
+
+
+def _fixup_url_spec(spec_file_name: str, url: str):
+    # url is like: https://example.com/path
+    parsed_url = urlparse(url)
+    http_proxy_spec = f'''
+  http-proxy:
+    - host-name: {parsed_url.hostname}
+      routes:
+        - path: '{parsed_url.path if parsed_url.path else "/"}'
+          proxy-to: webapp:3000
+    '''
+    spec_file_path = Path(spec_file_name)
+    with open(spec_file_path) as rfile:
+        contents = rfile.read()
+        contents = contents + http_proxy_spec
+    with open(spec_file_path, "w") as wfile:
+        wfile.write(contents)
+
+
+@click.group()
+@click.pass_context
+def command(ctx):
+    '''manage a webapp deployment'''
+
+    # Check that --stack wasn't supplied
+    if ctx.parent.obj.stack:
+        error_exit("--stack can't be supplied with the deploy-webapp command")
+
+
+@command.command()
+@click.option("--kube-config", help="Provide a config file for a k8s deployment")
+@click.option("--image-registry", help="Provide a container image registry url for this k8s cluster")
+@click.option("--deployment-dir", help="Create deployment files in this directory", required=True)
+@click.option("--image", help="image to deploy", required=True)
+@click.option("--url", help="url to serve", required=True)
+@click.option("--env-file", help="environment file for webapp")
+@click.pass_context
+def create(ctx, deployment_dir, image, url, kube_config, image_registry, env_file):
+    '''create a deployment for the specified webapp container'''
+    # Do the equivalent of:
+    # 1. laconic-so --stack webapp-template deploy --deploy-to k8s init --output webapp-spec.yml
+    #   --config (eqivalent of the contents of my-config.env)
+    # 2. laconic-so  --stack webapp-template deploy --deploy-to k8s create --deployment-dir test-deployment
+    #   --spec-file webapp-spec.yml
+    # 3. Replace the container image tag with the specified image
+    deployment_dir_path = Path(deployment_dir)
+    # Check the deployment dir does not exist
+    if deployment_dir_path.exists():
+        error_exit(f"Deployment dir {deployment_dir} already exists")
+    # Generate a temporary file name for the spec file
+    tf = NamedTemporaryFile(prefix="webapp-", suffix=".yml", delete=False)
+    spec_file_name = tf.name
+    # Specify the webapp template stack
+    stack = "webapp-template"
+    # TODO: support env file
+    deploy_command_context: DeployCommandContext = create_deploy_context(
+        global_options2(ctx), None, stack, None, None, None, env_file, "k8s"
+        )
+    init_operation(
+        deploy_command_context,
+        stack,
+        "k8s",
+        None,
+        env_file,
+        kube_config,
+        image_registry,
+        spec_file_name,
+        None
+    )
+    # Add the TLS and DNS spec
+    _fixup_url_spec(spec_file_name, url)
+    create_operation(
+        deploy_command_context,
+        spec_file_name,
+        deployment_dir,
+        None,
+        None
+    )
+    # Fix up the container tag inside the deployment compose file
+    _fixup_container_tag(deployment_dir, image)
+    os.remove(spec_file_name)
@@ -22,18 +22,21 @@

 import hashlib
 import click
-
 from dotenv import dotenv_values
+
+from stack_orchestrator import constants
 from stack_orchestrator.deploy.deployer_factory import getDeployer

+WEBAPP_PORT = 3000
+

@click.command()
@click.option("--image", help="image to deploy", required=True)
-@click.option("--deploy-to", default="compose", help="deployment type ([Docker] 'compose' or 'k8s')")
@click.option("--env-file", help="environment file for webapp")
+@click.option("--port", help="port to use (default random)")
@click.pass_context
-def command(ctx, image, deploy_to, env_file):
-    '''build the specified webapp container'''
+def command(ctx, image, env_file, port):
+    '''run the specified webapp container'''

    env = {}
    if env_file:
@@ -43,16 +46,19 @@ def command(ctx, image, deploy_to, env_file):
    hash = hashlib.md5(unique_cluster_descriptor.encode()).hexdigest()
    cluster = f"laconic-webapp-{hash}"

-    deployer = getDeployer(deploy_to,
+    deployer = getDeployer(type=constants.compose_deploy_type,
                           deployment_context=None,
                           compose_files=None,
                           compose_project_name=cluster,
                           compose_env_file=None)

-    container = deployer.run(image, command=[], user=None, volumes=[], entrypoint=None, env=env, detach=True)
+    ports = []
+    if port:
+        ports = [(port, WEBAPP_PORT)]
+    container = deployer.run(image, command=[], user=None, volumes=[], entrypoint=None, env=env, ports=ports, detach=True)

    # Make configurable?
-    webappPort = "3000/tcp"
+    webappPort = f"{WEBAPP_PORT}/tcp"
    # TODO: This assumes a Docker container object...
    if webappPort in container.network_settings.ports:
        mapping = container.network_settings.ports[webappPort][0]
@@ -20,7 +20,7 @@ from stack_orchestrator.repos import setup_repositories
 from stack_orchestrator.build import build_containers
 from stack_orchestrator.build import build_npms
 from stack_orchestrator.build import build_webapp
-from stack_orchestrator.deploy import run_webapp
+from stack_orchestrator.deploy.webapp import run_webapp, deploy_webapp
 from stack_orchestrator.deploy import deploy
 from stack_orchestrator import version
 from stack_orchestrator.deploy import deployment
@@ -52,6 +52,7 @@ cli.add_command(build_containers.command, "build-containers")
 cli.add_command(build_npms.command, "build-npms")
 cli.add_command(build_webapp.command, "build-webapp")
 cli.add_command(run_webapp.command, "run-webapp")
+cli.add_command(deploy_webapp.command, "deploy-webapp")
 cli.add_command(deploy.command, "deploy")  # deploy is an alias for deploy-system
 cli.add_command(deploy.command, "deploy-system")
 cli.add_command(deployment.command, "deployment")
@@ -18,6 +18,8 @@ import os.path
 import sys
 import ruamel.yaml
 from pathlib import Path
+from dotenv import dotenv_values
+from typing import Mapping


 def include_exclude_check(s, include, exclude):
@@ -178,3 +180,7 @@ def global_options2(ctx):
 def error_exit(s):
    print(f"ERROR: {s}")
    sys.exit(1)
+
+
+def env_var_map_from_file(file: Path) -> Mapping[str, str]:
+    return dotenv_values(file)
Author	SHA1	Message	Date
srwadleigh	6662252649	update pod name	2023-12-06 21:52:23 +00:00
srwadleigh	0b88d47832	clean up readme formatting	2023-12-06 21:51:36 +00:00
srwadleigh	62a78d48fc	fix typo in readme	2023-12-06 21:49:49 +00:00
srwadleigh	80713153d8	Merge remote-tracking branch 'origin/main' into keycloak	2023-12-06 21:44:12 +00:00
telackey	077ea80c70	Add `deployment status` command and fix k8s output for `deployment ps` (#679 )	2023-12-06 09:27:47 -07:00
dboreham	15faed00de	Generate a unique deployment id for each deployment (#680 ) * Move cluster name generation into a function * Generate a unique deployment id for each deployment	2023-12-05 22:56:58 -07:00
prathamesh0	6bef0c5b2f	Separate out GQL proxy server from uniswap-urbit stack (#681 ) * Separate out uniswap gql proxy in a stack * Use proxy server from watcher-ts * Add a flag to enable/disable the proxy server * Update env configuratoin for uniswap urbit app stack * Update stack file for uniswap urbit app stack * Fix env variables in instructions	2023-12-06 10:41:10 +05:30
prathamesh0	f27da19808	Use IPFS for hosting glob files for Urbit (#677 ) * Use IPFS for hosting glob files for Urbit * Add env configuration for IPFS endpoints to instructions * Make ship pier dir configurable in remote deployment script * Update remote deployment script to accept glob hash arg	2023-12-05 15:00:03 +05:30
telackey	2dd54892a1	Allow specifying the webapp tag explicitly (#675 )	2023-12-04 21:39:16 -06:00
telackey	ab0e70ed83	Change path portion of unique cluster name to point to compose file, not argv[0]. (#678 )	2023-12-04 13:39:14 -06:00
nabarunandprathamesh	c319e90ddd	Add a stack for running uniswap frontend on urbit (#670 ) * Create uniswap-frontend stack * Add stack for building uniswap frontend app * Add a container for Urbit fake ship * Update with deployment command * Add a service for uniswap app deployment to urbit * Use a script to start urbit ship to handle restarts * Rename stack name to uniswap-urbit-app * Rename build.sh to build-app.sh and check if build already exists * Rename stack directory name * Update uniswap build restart on failure * Perform uniswap app deployment in the urbit container * Add steps to create glob for the app * Tail /dev/null after deployment * Add steps to install the app to desk * Host glob files for uniswap * Update repo branch * Update readme with command to get urbit password * Update readme * Update readme to open urbit web UI * Expose the port on glob hosting container * Avoid exposing urbit http port * Add scripts for installing uniswap on remote urbit instance * Configure GQL proxy for uniswap app * Use laconic branch for app repo * Rename urbit pod for uniswap app deployment --------- Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>	2023-12-04 18:39:19 +05:30
telackey	2173e7ce6a	If the next version is unsupported, print a big warning and try higher version. (#674 )	2023-11-30 12:33:06 -06:00
dboreham	c19559967d	Add doc for deploy-webapp (#672 )	2023-11-29 20:55:14 -07:00
dboreham	d7093277b4	Use constants (#671 )	2023-11-29 20:50:53 -07:00
telackey	03a3645b3c	Add --port option to run-webapp. (#667 ) * Add --port option to run-webapp * Fixed merge * lint	2023-11-29 11:32:28 -06:00
dboreham	113c0bfbf1	Propagate env file for webapp deployment (#669 )	2023-11-28 21:14:02 -07:00
dboreham	1a069a6816	Use a temp file for the spec file name (#668 )	2023-11-28 19:56:12 -07:00
dboreham	a68cd5d65c	Webapp deploy (#662 )	2023-11-27 22:02:16 -07:00
nabarun	1b94db27c1	Upgrade azimuth watcher release version to `0.1.2` (#666 ) * Upgrade azimuth watcher release version * Fix version for azimuth watcher repo	2023-11-24 14:05:37 +05:30
prathamesh0	9499941891	Increase max connections for Azimuth watcher dbs (#665 )	2023-11-23 19:11:02 +05:30
nabarun neeraj prathamesh	3fefc67e77	Run azimuth contract watcher in active mode (#661 ) * Update stack to run azimuth job runner * Run azimuth watcher in active mode * Update stack to run job-runners for all watchers * Update ports in job-runner health checks * Map metrics ports to host * Configure historical block processing batch size for Azimuth watcher * Use deployment command for azimuth stack --------- Co-authored-by: neeraj <neeraj.rtly@gmail.com> Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>	2023-11-23 15:00:18 +05:30
telackey	1a37255c18	Tweak laconicd config to allow setting endpoint port and to make the fixturenet restartable. (#660 ) * Endpoint includes port * Make it restartable * Don't try to remove the mounted directory * Make copy of init.sh	2023-11-22 11:31:30 -06:00
dboreham	87bedde5cb	Support for k8s ingress and tls (#659 )	2023-11-21 16:04:36 -07:00
srwadleigh	ca057925da	update readme	2023-10-25 17:59:47 +00:00
srwadleigh	a3e141769a	initial pass at a standalone keycloak stack	2023-10-25 17:47:33 +00:00