#!/usr/bin/env python3 """Unattended driver for scripts/pipeline.sh (standard library only). Every minute it asks the public code repository for the head of the branch. When it moved, the new code is installed as a fresh snapshot behind the `repo` symlink (running processes are not disturbed). It then applies control requests committed to the repository and (re)starts the pipeline when it is not running and either the code changed or a reset asked for it: control/reset.txt lines " [kill] ..." - forget those stages so they run again ("kill" first stops a running pipeline); each id is applied once control/run.env KEY=VALUE lines passed to the pipeline (budgets etc.) While the pipeline runs, logs are pushed every 10 minutes. Create $EMC_ROOT/STOP to end it. """ import io import os import re import shutil import signal import subprocess import tarfile import time import urllib.request from pathlib import Path ROOT = Path(os.environ.get("EMC_ROOT", str(Path.home() / "emc"))).resolve() SOURCE = os.environ.get("EMC_SOURCE", "Mudassiruddin7/EMC") BRANCH = os.environ.get("EMC_BRANCH", "main") UV = os.environ.get("UV", "uv") LOGS, STATE, CODE = ROOT / "logs", ROOT / "state", ROOT / "code" VENV_PY = ROOT / "venv" / "bin" / "python" def log(msg): print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}", flush=True) def tool_env(): return dict(os.environ, UV_CACHE_DIR=str(ROOT / "uv-cache"), UV_PYTHON_INSTALL_DIR=str(ROOT / "uv-python"), UV_LINK_MODE="copy", TMPDIR=str(ROOT / "tmp"), HF_HOME=str(ROOT / "hf")) def remote_sha(): req = urllib.request.Request(f"https://github.com/{SOURCE}.git/info/refs?service=git-upload-pack", headers={"User-Agent": "git/2.45.0"}) body = urllib.request.urlopen(req, timeout=30).read().decode("latin-1") m = re.search(r"([0-9a-f]{40}) refs/heads/" + re.escape(BRANCH) + r"(?![\w./-])", body) return m.group(1) if m else None def complete(code_dir): """A code snapshot is usable only with its commit stamp and the pipeline script (folders can survive a machine change without their files).""" return (code_dir / ".commit").is_file() and (code_dir / "scripts" / "pipeline.sh").is_file() def install(sha): dest = CODE / sha[:12] if dest.exists() and not complete(dest): shutil.rmtree(dest, ignore_errors=True) if not dest.exists(): data = urllib.request.urlopen(f"https://codeload.github.com/{SOURCE}/tar.gz/{sha}", timeout=300).read() tmp = CODE / f".{sha[:12]}.tmp" shutil.rmtree(tmp, ignore_errors=True) tmp.mkdir(parents=True) with tarfile.open(fileobj=io.BytesIO(data)) as tf: members = [] for m in tf.getmembers(): name = m.name.split("/", 1)[1] if "/" in m.name else "" if name and not name.startswith("/") and ".." not in Path(name).parts: m.name = name members.append(m) try: tf.extractall(tmp, members=members, filter="data") except TypeError: tf.extractall(tmp, members=members) (tmp / ".commit").write_text(sha + "\n") tmp.rename(dest) link = ROOT / "repo" if link.exists() and not link.is_symlink(): link.rename(CODE / f"legacy-{int(time.time())}") tmp_link = ROOT / ".repo-link" if tmp_link.is_symlink() or tmp_link.exists(): tmp_link.unlink() tmp_link.symlink_to(dest, target_is_directory=True) os.replace(tmp_link, link) def ensure_venv(): """A private Python with huggingface_hub, so logs can be pushed from the very first stage.""" if not VENV_PY.exists(): subprocess.run([UV, "venv", "--python", "3.12", str(ROOT / "venv")], check=True, env=tool_env()) subprocess.run([UV, "pip", "install", "--python", str(VENV_PY), "huggingface_hub"], check=True, env=tool_env(), stdout=subprocess.DEVNULL) def read_control(): env, resets = {}, [] p = ROOT / "repo" / "control" / "run.env" if p.exists(): for line in p.read_text().splitlines(): line = line.strip() if line and not line.startswith("#") and "=" in line: k, v = line.split("=", 1) env[k.strip()] = v.strip() applied = set((STATE / "applied_resets").read_text().split()) if (STATE / "applied_resets").exists() else set() p = ROOT / "repo" / "control" / "reset.txt" if p.exists(): for line in p.read_text().splitlines(): parts = line.split() if parts and not parts[0].startswith("#") and parts[0] not in applied: resets.append((parts[0], "kill" in parts[1:], [s for s in parts[1:] if s != "kill"])) return env, resets def stop(proc): try: os.killpg(proc.pid, signal.SIGTERM) proc.wait(timeout=90) except subprocess.TimeoutExpired: os.killpg(proc.pid, signal.SIGKILL) proc.wait() except ProcessLookupError: pass def sync(): if VENV_PY.exists() and (ROOT / "repo" / "scripts" / "sync.py").exists(): try: with open(LOGS / "sync.log", "a") as f: subprocess.run([str(VENV_PY), str(ROOT / "repo" / "scripts" / "sync.py")], stdout=f, stderr=subprocess.STDOUT, env=dict(tool_env(), EMC_ROOT=str(ROOT)), timeout=1200) except Exception as e: # noqa: BLE001 - an upload problem never stops the supervisor log(f"log push failed: {type(e).__name__}: {e}") def start_pipeline(extra): run_sh = ROOT / "pipeline.run.sh" # a copy: bash reads scripts while running them shutil.copy(ROOT / "repo" / "scripts" / "pipeline.sh", run_sh) env = tool_env() env.update(extra) env.update(EMC_ROOT=str(ROOT), EMC_REPO=str(ROOT / "repo"), UV=UV) out = open(LOGS / "pipeline.out", "a") return subprocess.Popen(["bash", str(run_sh)], stdout=out, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, env=env, cwd=str(ROOT), start_new_session=True) def main(): for d in (LOGS, STATE, CODE, ROOT / "tmp"): d.mkdir(parents=True, exist_ok=True) (ROOT / "supervisor.pid").write_text(str(os.getpid())) if os.environ.get("RUN_ID") and not (STATE / "run_id").exists(): (STATE / "run_id").write_text(os.environ["RUN_ID"] + "\n") head = ROOT / "repo" / ".commit" current = head.read_text().strip() if complete(ROOT / "repo") else "" ran = (STATE / "pipeline_commit").read_text().strip() if (STATE / "pipeline_commit").exists() else "" # force: (re)start the pipeline once on every supervisor start - finished stages are skipped, # and a machine restart in the middle of a stage resumes there. proc, last_sync, force, reported, venv_ok = None, 0.0, True, True, False log(f"supervisor started in {ROOT}") while not (ROOT / "STOP").exists(): try: sha = remote_sha() if sha and sha != current: install(sha) current = sha log(f"code updated to {sha[:12]}") except Exception as e: # noqa: BLE001 - network hiccups are retried next minute log(f"code check failed: {type(e).__name__}: {e}") if not venv_ok: try: ensure_venv() venv_ok = True except Exception as e: # noqa: BLE001 log(f"python environment not ready yet: {e}") env, resets = read_control() running = proc is not None and proc.poll() is None for rid, kill, stages in resets: if running and not kill: continue if running: stop(proc) running = False log("pipeline stopped for a reset") for s in stages: for suffix in ("done", "failed"): (STATE / f"{s}.{suffix}").unlink(missing_ok=True) with open(STATE / "applied_resets", "a") as f: f.write(rid + "\n") log(f"reset {rid}: {' '.join(stages)}") force = True if not running: if proc is not None and not reported: log(f"pipeline exited with code {proc.returncode}") reported = True sync() if current and not complete(ROOT / "repo"): current = "" # snapshot lost its files: fetch it again next minute log("code snapshot incomplete; reinstalling") elif current and (current != ran or force): try: proc = start_pipeline(env) except Exception as e: # noqa: BLE001 - retried next minute log(f"pipeline start failed: {type(e).__name__}: {e}") time.sleep(60) continue ran, force, reported, last_sync = current, False, False, time.time() (STATE / "pipeline_commit").write_text(current + "\n") log(f"pipeline started (pid {proc.pid}) at {current[:12]}") elif time.time() - last_sync > 600: try: sync() except Exception as e: # noqa: BLE001 log(f"log push failed: {e}") last_sync = time.time() time.sleep(60) log("stop requested") if __name__ == "__main__": main()