Portainer vs Dockge vs Komodo on one compose stack

#!/usr/bin/env bash
# docker-ui: Portainer CE 2.45.3, Dockge 1.5.0 and Komodo 2.3.4, each in its own VM, managing the same two-service compose.
# Deploys it, changes the web image tag three times, fetches logs, then records RAM, the Docker socket mounts and the data store.
# Usage: run.sh [portainer] [dockge] [komodo]
set -uo pipefail
source "$(dirname "$0")/../_dlib.sh"
T=docker-ui; OUT="$ROOT/evidence/tests/$T"; RAW="$OUT/raw"; D="$ROOT/lab/tests/$T"
TOOLS=("$@"); [ ${#TOOLS[@]} -eq 0 ] && TOOLS=(portainer dockge komodo)
[ $# -eq 0 ] && rm -rf "$OUT"; mkdir -p "$RAW"
declare -A PROJ=([portainer]=pt [dockge]=dk [komodo]=km)
declare -A NAMES=([portainer]="pt-portainer-1" [dockge]="dk-dockge-1" [komodo]="km-mongo-1 km-core-1 km-periphery-1")
one() {
  local tool="$1" p="${PROJ[$1]}"
  start_vm d-$T-$tool
  gx 'mkdir -p ~/t; sudo mkdir -p /opt/stacks /etc/komodo; sudo chown lab /opt/stacks'
  vm scp-to "$ROOT/lab/stacks/$tool/compose.yml" t/compose.yml >/dev/null
  vm scp-to "$D/uitest.py" uitest.py >/dev/null; vm scp-to "$D/dockge-drive.js" dockge-drive.js >/dev/null; vm scp-to "$ROOT/lab/tests/_dsample.py" sample.py >/dev/null
  dpull nginx:1.28-alpine nginx:1.29-alpine redis:7.4-alpine
  cpull '~/t' $p
  gx "cd ~/t && docker compose -p $p up -d 2>&1 | tail -1"
  case $tool in
    portainer) until gx 'curl -sf http://127.0.0.1:8080/api/system/status >/dev/null'; do sleep 2; done ;;
    dockge) until gx 'curl -sf -o /dev/null http://127.0.0.1:8080/'; do sleep 2; done; gx 'docker cp ~/dockge-drive.js dk-dockge-1:/tmp/d.js' ;;
    komodo) until gx 'curl -sf -o /dev/null http://127.0.0.1:8080/'; do sleep 2; done; sleep 40 ;;
  esac
  sleep 15
  gx "python3 ~/uitest.py $tool" > "$RAW/$tool-uitest.json" 2> "$RAW/$tool-uitest.err"
  sleep 30
  gx "python3 ~/sample.py ${NAMES[$tool]}" > "$RAW/$tool-ram-managing.json"
  gx "docker inspect -f '{{.Name}} {{range .Mounts}}[{{.Type}} {{.Source}} -> {{.Destination}} {{.Mode}}] {{end}}' \$(docker ps -q) | sort; echo; sudo sh -c \"for d in /var/lib/docker/volumes/${p}_*/_data; do echo \\\$d; ls -la \\\$d | head -12; done\"" > "$RAW/$tool-mounts-and-data.txt" 2>&1
  gx 'docker inspect -f "{{.Name}} restarts={{.RestartCount}}" $(docker ps -aq)' > "$RAW/$tool-restarts.txt" 2>&1
  local S="$ROOT/public/shots/$T"
  case $tool in
    portainer) shot 8080 / "$S/portainer.png" '[{"wait":6000},{"fill":"#username","value":"admin"},{"fill":"#password","value":"lab-only-not-a-secret"},{"press":"Enter"},{"wait":8000},{"goto":"http://127.0.0.1:18391/#!/1/docker/containers"},{"wait":8000}]' ;;
    dockge) shot 8080 / "$S/dockge.png" '[{"wait":4000},{"fill":"input[placeholder=Username]","value":"admin"},{"fill":"input[placeholder=Password]","value":"lab-only-not-a-secret"},{"press":"Enter"},{"wait":6000},{"click":"text=demo"},{"wait":10000},{"dump":".xterm-rows"}]' > "$RAW/dockge-ui-text.txt" 2>&1 ;;
    komodo) shot 8080 / "$S/komodo.png" '[{"wait":6000},{"fill":"input[placeholder=\"Enter username\"]","value":"admin"},{"fill":"input[placeholder=\"Enter password\"]","value":"lab-only-not-a-secret"},{"press":"Enter"},{"wait":8000},{"goto":"http://127.0.0.1:18391/stacks"},{"wait":8000}]' ;;
  esac
  mkdir -p "$RAW/$tool-env"; collect_env "$RAW/$tool-env"
}
for t in "${TOOLS[@]}"; do ( one "$t" ); done
python3 "$D/summarize.py" "$RAW" "$OUT"

#!/usr/bin/env python3
"""Runs in the VM. Usage: uitest.py portainer|dockge|komodo. Drives the tool the way its UI does (through the API it calls) to
deploy the same two-service compose (nginx web + redis cache), then change the web image tag three times, and fetch logs.
Times are from the request until `docker inspect` shows the web container running with the expected image (images pre-pulled)."""
import json, subprocess, sys, time, urllib.request, urllib.parse
tool = sys.argv[1]; PW = "lab-only-not-a-secret"; B = "http://127.0.0.1:8080"
def sh(c, check=True): return subprocess.run(c, shell=True, capture_output=True, text=True, check=check)
def yml(web): return f"services:\n  web:\n    image: {web}\n  cache:\n    image: redis:7.4-alpine\n"
def web_state():
    r = sh("docker inspect -f '{{.Config.Image}} {{.State.Status}} {{.Id}}' demo-web-1", False)
    if r.returncode: return None
    i, st, cid = r.stdout.split(); return i, st, cid
def wait_web(image, old_id, timeout=180):
    t = time.perf_counter()
    while time.perf_counter() - t < timeout:
        s = web_state()
        if s and s[0] == image and s[1] == "running" and s[2] != old_id: return time.perf_counter() - t, s[2]
        time.sleep(0.05)
    raise SystemExit(json.dumps({"error": f"web never reached {image}", "state": web_state()}))
def http(method, path, body=None, headers=None, raw=False):
    h = {"content-type": "application/json", **(headers or {})}
    try:
        r = urllib.request.urlopen(urllib.request.Request(B + path, data=json.dumps(body).encode() if body is not None else None, headers=h, method=method), timeout=180)
    except urllib.error.HTTPError as e:
        raise RuntimeError(f"HTTP {e.code} on {method} {path}: {e.read().decode()[:400]}")
    d = r.read(); return d if raw else (json.loads(d) if d else None)
out = {"tool": tool, "steps": []}
IMGS = ["nginx:1.28-alpine", "nginx:1.29-alpine", "nginx:1.28-alpine", "nginx:1.29-alpine"]  # first is the deploy, then three image changes
if tool == "portainer":
    tok = sh("docker logs pt-portainer-1 2>&1 | grep -o 'setup_token=[0-9a-f]*' | head -1 | cut -d= -f2").stdout.strip()
    http("POST", "/api/users/admin/init", {"Username": "admin", "Password": PW}, {"X-Setup-Token": tok})
    jwt = http("POST", "/api/auth", {"Username": "admin", "Password": PW})["jwt"]; A = {"Authorization": "Bearer " + jwt}
    r = urllib.request.Request(B + "/api/endpoints", data=b"--x\r\nContent-Disposition: form-data; name=\"Name\"\r\n\r\nlocal\r\n--x\r\nContent-Disposition: form-data; name=\"EndpointCreationType\"\r\n\r\n1\r\n--x--\r\n", headers={**A, "content-type": "multipart/form-data; boundary=x"}, method="POST")
    out["environment_created"] = json.load(urllib.request.urlopen(r))["Name"]
    def deploy(y, first):
        if first: return http("POST", "/api/stacks/create/standalone/string?endpointId=1", {"name": "demo", "stackFileContent": y, "env": []}, A)
        for _ in range(120):  # an update sent while the previous deploy is still finishing is refused with HTTP 409, so wait for status 1 (active)
            if http("GET", "/api/stacks/1", None, A)["Status"] == 1: break
            time.sleep(1)
        return http("PUT", "/api/stacks/1?endpointId=1", {"stackFileContent": y, "env": [], "prune": False, "pullImage": True}, A)
    def logs():
        cid = sh("docker ps -q --filter name=demo-web").stdout.strip()
        d = http("GET", f"/api/endpoints/1/docker/containers/{cid}/logs?stdout=1&stderr=1&tail=20", None, A, raw=True)
        return d.decode("utf-8", "replace")
elif tool == "komodo":
    jwt = http("POST", "/auth/login", {"type": "LoginLocalUser", "params": {"username": "admin", "password": PW}})["data"]["jwt"]; A = {"Authorization": jwt}
    def deploy(y, first):
        # an UpdateStack sent while the previous DeployStack is still running is refused ("Stack busy"), so wait for that update to complete first
        for _ in range(120):
            if not getattr(deploy, "pending", None): break
            if http("POST", "/read", {"type": "GetUpdate", "params": {"id": deploy.pending}}, A).get("status") == "Complete": break
            time.sleep(1)
        if first: http("POST", "/write", {"type": "CreateStack", "params": {"name": "demo", "config": {"server_id": "Local", "file_contents": y}}}, A)
        else: http("POST", "/write", {"type": "UpdateStack", "params": {"id": "demo", "config": {"file_contents": y}}}, A)
        u = http("POST", "/execute", {"type": "DeployStack", "params": {"stack": "demo"}}, A)
        deploy.pending = u["_id"]["$oid"]; return u
    def logs():
        return http("POST", "/read", {"type": "GetStackLog", "params": {"stack": "demo", "services": [], "tail": 20}}, A)["stdout"]
else:  # dockge: its socket API, through a node script inside the container
    sh("docker exec dk-dockge-1 node /tmp/d.js setup")
    def deploy(y, first):
        img = [l.split("image:")[1].strip() for l in y.splitlines() if "nginx" in l][0]
        return json.loads(sh(f"docker exec dk-dockge-1 node /tmp/d.js {'add' if first else 'deploy'} {img}").stdout)
    def logs(): return "(see the UI screenshot step: Dockge streams logs into a terminal panel through a pty)"
old = None
for n, img in enumerate(IMGS):
    t = time.perf_counter(); r = deploy(yml(img), n == 0); api_s = time.perf_counter() - t
    took, old = wait_web(img, old, 180); total = api_s + took
    out["steps"].append({"what": "deploy" if n == 0 else f"change web image to {img}", "image": img, "api_call_s": round(api_s, 3), "total_s_until_container_running": round(total, 3)})
time.sleep(5)
lg = logs(); out["logs_sample"] = lg[-700:]; out["log_lines_returned"] = len([l for l in lg.splitlines() if l.strip()])
out["web_image_final"] = sh("docker inspect -f '{{.Config.Image}}' demo-web-1").stdout.strip()
print(json.dumps(out, indent=1))

// Runs inside the Dockge container (socket.io-client ships in /app/node_modules). Drives Dockge's socket API the way its web UI does.
// Usage: node dockge-drive.js setup | deploy <web-image> | add <web-image>
// "add" creates the stack (isAdd=true); "deploy" saves the edited compose file and redeploys it (isAdd=false), which is what Edit > Deploy does.
const { io } = require("/app/node_modules/socket.io-client");
const PW = "lab-only-not-a-secret";
const [step, image] = process.argv.slice(2);
const yaml = (web) => `services:\n  web:\n    image: ${web}\n  cache:\n    image: redis:7.4-alpine\n`;
const s = io("http://127.0.0.1:5001");
const call = (ev, ...a) => new Promise((res) => s.emit(ev, ...a, res));
s.on("connect", async () => {
  let r;
  try {
    if (step === "setup") r = await call("setup", "admin", PW);
    else {
      r = await call("login", { username: "admin", password: PW, token: "" });
      if (!r.ok) throw new Error("login: " + JSON.stringify(r));
      r = await call("agent", "", "deployStack", "demo", yaml(image), "", step === "add");
    }
    console.log(JSON.stringify({ step, image, r }));
  } catch (e) { console.log(JSON.stringify({ step, error: String(e) })); }
  process.exit(0);
});
setTimeout(() => { console.log(JSON.stringify({ step, error: "timeout" })); process.exit(1); }, 180000);