^sOBj0YT
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
literal 0
HcmV?d00001
diff --git a/uptime-updates/config.yml b/uptime-updates/config.yml
new file mode 100644
index 0000000..7ad8638
--- /dev/null
+++ b/uptime-updates/config.yml
@@ -0,0 +1,9 @@
+uptime_kuma:
+ url: "http://127.0.0.1:3001"
+ api_key: "PUT_YOUR_API_KEY_HERE"
+
+# Optional bot behavior settings
+bot:
+ dry_run: false
+ request_timeout_seconds: 10
+ poll_interval_seconds: 60
diff --git a/uptime-updates/container-monitor-map.yaml b/uptime-updates/container-monitor-map.yaml
new file mode 100644
index 0000000..0d12108
--- /dev/null
+++ b/uptime-updates/container-monitor-map.yaml
@@ -0,0 +1,43 @@
+# Container to Uptime Kuma monitor mapping
+#
+# Fill in one item per container you want tracked.
+# The bot can read this file to know:
+# 1) which Docker host to query
+# 2) which container on that host to watch
+# 3) which Uptime Kuma monitor to update when container ID changes
+#
+# Notes:
+# - uptime_monitor_id is the numeric ID in Uptime Kuma.
+# You can get it from the monitor URL, e.g. /dashboard/42 -> 42
+# - host_api should be the Docker API endpoint for that host.
+# Example: tcp://10.0.84.21:2375
+# - container_name should match docker container name used by that host.
+#
+# Optional fields:
+# - enabled: true/false (default true)
+# - expected_uptime_type: set to "docker" to protect against wrong monitor type updates
+
+mappings:
+ - name: "media-server jellyfin"
+ enabled: true
+ host_label: "media-server"
+ host_api: "tcp://10.0.84.21:2375"
+ container_name: "jellyfin"
+ uptime_monitor_id: 21
+ expected_uptime_type: "docker"
+
+ - name: "nas immich"
+ enabled: true
+ host_label: "nas"
+ host_api: "tcp://10.0.84.22:2375"
+ container_name: "immich-server"
+ uptime_monitor_id: 34
+ expected_uptime_type: "docker"
+
+ - name: "lab pihole"
+ enabled: false
+ host_label: "lab"
+ host_api: "tcp://10.0.84.30:2375"
+ container_name: "pihole"
+ uptime_monitor_id: 56
+ expected_uptime_type: "docker"
diff --git a/uptime-updates/export-watchtower-bundle.sh b/uptime-updates/export-watchtower-bundle.sh
new file mode 100644
index 0000000..e395a84
--- /dev/null
+++ b/uptime-updates/export-watchtower-bundle.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUT_DIR="${SCRIPT_DIR}/watchtower-export"
+BUNDLE_NAME="uptime-watchtower-bundle-$(date +%Y%m%d-%H%M%S).tar.gz"
+
+mkdir -p "${OUT_DIR}"
+
+cp -f "${SCRIPT_DIR}/uptime-bot.py" "${OUT_DIR}/uptime-bot.py"
+cp -f "${SCRIPT_DIR}/requirements.txt" "${OUT_DIR}/requirements.txt"
+cp -f "${SCRIPT_DIR}/config.yml" "${OUT_DIR}/config.yml"
+cp -f "${SCRIPT_DIR}/container-monitor-map.yaml" "${OUT_DIR}/container-monitor-map.yaml"
+
+if [[ ! -f "${OUT_DIR}/Dockerfile" ]]; then
+ echo "Missing ${OUT_DIR}/Dockerfile"
+ exit 1
+fi
+
+if [[ ! -f "${OUT_DIR}/docker-compose.watchtower-uptime-sync.yml" ]]; then
+ echo "Missing ${OUT_DIR}/docker-compose.watchtower-uptime-sync.yml"
+ exit 1
+fi
+
+if [[ ! -f "${OUT_DIR}/docker-compose.watchtower-embedded.yml" ]]; then
+ echo "Missing ${OUT_DIR}/docker-compose.watchtower-embedded.yml"
+ exit 1
+fi
+
+if [[ ! -f "${OUT_DIR}/watchtower-embedded/Dockerfile.watchtower-with-uptime-bot" ]]; then
+ echo "Missing ${OUT_DIR}/watchtower-embedded/Dockerfile.watchtower-with-uptime-bot"
+ exit 1
+fi
+
+if [[ ! -f "${OUT_DIR}/watchtower-embedded/start-watchtower-with-uptime-bot.sh" ]]; then
+ echo "Missing ${OUT_DIR}/watchtower-embedded/start-watchtower-with-uptime-bot.sh"
+ exit 1
+fi
+
+cd "${OUT_DIR}"
+tar -czf "${BUNDLE_NAME}" \
+ Dockerfile \
+ docker-compose.watchtower-uptime-sync.yml \
+ docker-compose.watchtower-embedded.yml \
+ uptime-bot.py \
+ requirements.txt \
+ config.yml \
+ container-monitor-map.yaml \
+ watchtower-embedded/Dockerfile.watchtower-with-uptime-bot \
+ watchtower-embedded/start-watchtower-with-uptime-bot.sh
+
+echo "Bundle created: ${OUT_DIR}/${BUNDLE_NAME}"
diff --git a/uptime-updates/requirements.txt b/uptime-updates/requirements.txt
new file mode 100644
index 0000000..ecc9577
--- /dev/null
+++ b/uptime-updates/requirements.txt
@@ -0,0 +1,2 @@
+uptime-kuma-api>=1.2.1
+PyYAML>=6.0
diff --git a/uptime-updates/setup-update_uptime-bot.sh b/uptime-updates/setup-update_uptime-bot.sh
new file mode 100644
index 0000000..633db6e
--- /dev/null
+++ b/uptime-updates/setup-update_uptime-bot.sh
@@ -0,0 +1,426 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Installs or updates the uptime bot service and runtime files.
+# Intended usage:
+# sudo ./setup-update_uptime-bot.sh
+
+APP_NAME="uptime-updates-bot"
+SERVICE_NAME="${APP_NAME}.service"
+INSTALL_DIR="/opt/uptime-updates"
+RUN_AS_USER="root"
+RUN_AS_GROUP="root"
+ENABLE_ON_BOOT="true"
+START_AFTER_INSTALL="true"
+DRY_RUN="false"
+MIN_PYTHON_VERSION="3.9"
+VENV_DIR=""
+OVERWRITE_CONFIG="false"
+OVERWRITE_MAP="false"
+
+TIMESTAMP="$(date +%Y%m%d-%H%M%S)"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SYSTEMD_DIR="/etc/systemd/system"
+
+RUNNER_FILE=""
+RUNNER_EXEC=""
+
+log() {
+ echo "[INFO] $*"
+}
+
+warn() {
+ echo "[WARN] $*" >&2
+}
+
+err() {
+ echo "[ERROR] $*" >&2
+}
+
+usage() {
+ cat </dev/null 2>&1; then
+ echo "apt-get"
+ elif command -v dnf >/dev/null 2>&1; then
+ echo "dnf"
+ elif command -v yum >/dev/null 2>&1; then
+ echo "yum"
+ elif command -v zypper >/dev/null 2>&1; then
+ echo "zypper"
+ elif command -v pacman >/dev/null 2>&1; then
+ echo "pacman"
+ elif command -v apk >/dev/null 2>&1; then
+ echo "apk"
+ else
+ echo ""
+ fi
+}
+
+install_python3() {
+ local pm
+ pm="$(detect_package_manager)"
+
+ if [[ -z "${pm}" ]]; then
+ err "No supported package manager found to install Python automatically."
+ err "Install Python ${MIN_PYTHON_VERSION}+ manually, then re-run this script."
+ exit 1
+ fi
+
+ log "Attempting to install Python 3 using ${pm}"
+ case "${pm}" in
+ apt-get)
+ run_cmd "apt-get update"
+ run_cmd "apt-get install -y python3 python3-venv python3-pip"
+ ;;
+ dnf)
+ run_cmd "dnf install -y python3 python3-pip"
+ ;;
+ yum)
+ run_cmd "yum install -y python3 python3-pip"
+ ;;
+ zypper)
+ run_cmd "zypper --non-interactive install python3 python3-pip"
+ ;;
+ pacman)
+ run_cmd "pacman -Sy --noconfirm python python-pip"
+ ;;
+ apk)
+ run_cmd "apk add --no-cache python3 py3-pip"
+ ;;
+ *)
+ err "Unsupported package manager: ${pm}"
+ exit 1
+ ;;
+ esac
+}
+
+setup_python_environment() {
+ local venv_python
+ local requirements_path
+
+ VENV_DIR="${INSTALL_DIR}/.venv"
+ venv_python="${VENV_DIR}/bin/python"
+ requirements_path="${INSTALL_DIR}/requirements.txt"
+
+ log "Creating/updating Python virtual environment at ${VENV_DIR}"
+ run_cmd "python3 -m venv \"${VENV_DIR}\""
+
+ log "Installing Python dependencies for uptime bot"
+ run_cmd "\"${venv_python}\" -m pip install --upgrade pip"
+ if [[ -f "${requirements_path}" ]]; then
+ run_cmd "\"${venv_python}\" -m pip install -r \"${requirements_path}\""
+ else
+ warn "requirements.txt not found in install dir. Falling back to default dependencies."
+ run_cmd "\"${venv_python}\" -m pip install uptime-kuma-api PyYAML"
+ fi
+}
+
+ensure_python3_compatible() {
+ local py_ver
+
+ if ! command -v python3 >/dev/null 2>&1; then
+ warn "python3 not found; attempting automatic install."
+ install_python3
+ fi
+
+ if ! command -v python3 >/dev/null 2>&1; then
+ err "python3 is still unavailable after install attempt."
+ exit 1
+ fi
+
+ if [[ "${DRY_RUN}" == "true" ]]; then
+ log "Dry-run: skipping python version verification command."
+ return
+ fi
+
+ py_ver="$(python3 -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")')"
+ if version_ge "${py_ver}" "${MIN_PYTHON_VERSION}"; then
+ log "Detected python3 ${py_ver} (required: ${MIN_PYTHON_VERSION}+)"
+ return
+ fi
+
+ warn "Detected python3 ${py_ver}, but ${MIN_PYTHON_VERSION}+ is required. Trying to upgrade python3."
+ install_python3
+ py_ver="$(python3 -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")')"
+
+ if ! version_ge "${py_ver}" "${MIN_PYTHON_VERSION}"; then
+ err "python3 ${py_ver} is still below required ${MIN_PYTHON_VERSION}+ after install/upgrade attempt."
+ err "Please install a newer Python manually, then re-run this script."
+ exit 1
+ fi
+
+ log "Python upgraded to compatible version: ${py_ver}"
+}
+
+parse_args() {
+ while [[ $# -gt 0 ]]; do
+ case "$1" in
+ --install-dir)
+ shift
+ [[ $# -gt 0 ]] || { err "Missing value for --install-dir"; exit 1; }
+ INSTALL_DIR="$1"
+ ;;
+ --service-name)
+ shift
+ [[ $# -gt 0 ]] || { err "Missing value for --service-name"; exit 1; }
+ SERVICE_NAME="$1"
+ ;;
+ --user)
+ shift
+ [[ $# -gt 0 ]] || { err "Missing value for --user"; exit 1; }
+ RUN_AS_USER="$1"
+ ;;
+ --group)
+ shift
+ [[ $# -gt 0 ]] || { err "Missing value for --group"; exit 1; }
+ RUN_AS_GROUP="$1"
+ ;;
+ --no-enable)
+ ENABLE_ON_BOOT="false"
+ ;;
+ --no-start)
+ START_AFTER_INSTALL="false"
+ ;;
+ --min-python-version)
+ shift
+ [[ $# -gt 0 ]] || { err "Missing value for --min-python-version"; exit 1; }
+ MIN_PYTHON_VERSION="$1"
+ ;;
+ --overwrite-config)
+ OVERWRITE_CONFIG="true"
+ ;;
+ --overwrite-map)
+ OVERWRITE_MAP="true"
+ ;;
+ --overwrite-all)
+ OVERWRITE_CONFIG="true"
+ OVERWRITE_MAP="true"
+ ;;
+ --dry-run)
+ DRY_RUN="true"
+ ;;
+ -h|--help)
+ usage
+ exit 0
+ ;;
+ *)
+ err "Unknown argument: $1"
+ usage
+ exit 1
+ ;;
+ esac
+ shift
+ done
+}
+
+check_prereqs() {
+ command -v systemctl >/dev/null 2>&1 || { err "systemctl is required."; exit 1; }
+ command -v install >/dev/null 2>&1 || { err "install is required."; exit 1; }
+
+ if [[ -f "${SCRIPT_DIR}/uptime-bot.py" ]]; then
+ ensure_python3_compatible
+ RUNNER_FILE="uptime-bot.py"
+ VENV_DIR="${INSTALL_DIR}/.venv"
+ RUNNER_EXEC="${VENV_DIR}/bin/python ${INSTALL_DIR}/uptime-bot.py"
+ elif [[ -f "${SCRIPT_DIR}/uptime-bot.sh" ]]; then
+ RUNNER_FILE="uptime-bot.sh"
+ RUNNER_EXEC="/usr/bin/env bash ${INSTALL_DIR}/uptime-bot.sh"
+ else
+ err "No runner found. Create uptime-bot.py or uptime-bot.sh in ${SCRIPT_DIR}."
+ exit 1
+ fi
+
+ [[ -f "${SCRIPT_DIR}/config.yml" ]] || { err "Missing ${SCRIPT_DIR}/config.yml"; exit 1; }
+ [[ -f "${SCRIPT_DIR}/container-monitor-map.yaml" ]] || { err "Missing ${SCRIPT_DIR}/container-monitor-map.yaml"; exit 1; }
+}
+
+install_files() {
+ local src_config
+ local dst_config
+ local src_map
+ local dst_map
+
+ src_config="${SCRIPT_DIR}/config.yml"
+ dst_config="${INSTALL_DIR}/config.yml"
+ src_map="${SCRIPT_DIR}/container-monitor-map.yaml"
+ dst_map="${INSTALL_DIR}/container-monitor-map.yaml"
+
+ log "Installing files into ${INSTALL_DIR}"
+ run_cmd "mkdir -p \"${INSTALL_DIR}\""
+
+ if [[ -f "${dst_config}" && "${OVERWRITE_CONFIG}" != "true" ]]; then
+ warn "Keeping existing installed config.yml (use --overwrite-config to replace)."
+ else
+ if [[ -f "${dst_config}" && "${OVERWRITE_CONFIG}" == "true" ]]; then
+ run_cmd "cp -a \"${dst_config}\" \"${dst_config}.bak.${TIMESTAMP}\""
+ log "Backed up existing config.yml to ${dst_config}.bak.${TIMESTAMP}"
+ fi
+ run_cmd "install -m 0644 \"${src_config}\" \"${dst_config}\""
+ fi
+
+ if [[ -f "${dst_map}" && "${OVERWRITE_MAP}" != "true" ]]; then
+ warn "Keeping existing installed container-monitor-map.yaml (use --overwrite-map to replace)."
+ else
+ if [[ -f "${dst_map}" && "${OVERWRITE_MAP}" == "true" ]]; then
+ run_cmd "cp -a \"${dst_map}\" \"${dst_map}.bak.${TIMESTAMP}\""
+ log "Backed up existing container-monitor-map.yaml to ${dst_map}.bak.${TIMESTAMP}"
+ fi
+ run_cmd "install -m 0644 \"${src_map}\" \"${dst_map}\""
+ fi
+
+ if [[ -f "${SCRIPT_DIR}/requirements.txt" ]]; then
+ run_cmd "install -m 0644 \"${SCRIPT_DIR}/requirements.txt\" \"${INSTALL_DIR}/requirements.txt\""
+ fi
+ run_cmd "install -m 0755 \"${SCRIPT_DIR}/${RUNNER_FILE}\" \"${INSTALL_DIR}/${RUNNER_FILE}\""
+ run_cmd "install -m 0755 \"${SCRIPT_DIR}/setup-update_uptime-bot.sh\" \"${INSTALL_DIR}/setup-update_uptime-bot.sh\""
+
+ run_cmd "chown -R ${RUN_AS_USER}:${RUN_AS_GROUP} \"${INSTALL_DIR}\""
+}
+
+write_service() {
+ local service_path="${SYSTEMD_DIR}/${SERVICE_NAME}"
+
+ log "Writing service unit ${service_path}"
+ if [[ "${DRY_RUN}" == "true" ]]; then
+ cat < "${service_path}" < None:
+ global STOP
+ STOP = True
+ logging.info("Received signal %s, shutting down...", signum)
+
+
+def _load_yaml(path: str) -> Dict[str, Any]:
+ with open(path, "r", encoding="utf-8") as handle:
+ data = yaml.safe_load(handle) or {}
+ if not isinstance(data, dict):
+ raise ValueError(f"YAML root in {path} must be a mapping")
+ return data
+
+
+def _normalize_docker_host_url(raw_url: str) -> str:
+ if raw_url.startswith("tcp://"):
+ return "http://" + raw_url[len("tcp://") :]
+ if raw_url.startswith("http://") or raw_url.startswith("https://"):
+ return raw_url
+ raise ValueError(f"Unsupported host_api scheme: {raw_url}")
+
+
+def _docker_get_container_id(host_api: str, container_name: str, timeout_seconds: int) -> Optional[str]:
+ """Resolve a container name on a Docker host to its full container ID.
+
+ Uses Docker remote API endpoint: /containers/{name}/json
+ """
+ base_url = _normalize_docker_host_url(host_api).rstrip("/")
+ encoded_name = urllib.parse.quote(container_name, safe="")
+ url = f"{base_url}/containers/{encoded_name}/json"
+
+ request = urllib.request.Request(url=url, method="GET", headers={"Accept": "application/json"})
+
+ try:
+ with urllib.request.urlopen(request, timeout=timeout_seconds) as response:
+ payload = json.loads(response.read().decode("utf-8"))
+ except urllib.error.HTTPError as exc:
+ if exc.code == 404:
+ logging.warning("Container not found on host %s: %s", host_api, container_name)
+ return None
+ raise
+
+ container_id = payload.get("Id")
+ if not container_id:
+ raise RuntimeError(f"Docker API response missing Id for {container_name} on {host_api}")
+ return str(container_id)
+
+
+def _api_login(url: str, api_key: str) -> UptimeKumaApi:
+ api = UptimeKumaApi(url)
+ # Uptime Kuma API key auth in wrapper is login_by_token.
+ api.login_by_token(api_key)
+ return api
+
+
+def _update_monitor_container_id(
+ api: UptimeKumaApi,
+ monitor_id: int,
+ new_container_id: str,
+ dry_run: bool,
+) -> bool:
+ """Attempt to update docker_container for a monitor.
+
+ Returns True if monitor was updated, False if unchanged or dry-run.
+ """
+ monitor = api.get_monitor(monitor_id)
+ if not isinstance(monitor, dict):
+ raise RuntimeError(f"Unexpected monitor payload for id {monitor_id}: {type(monitor)}")
+
+ current_id = str(monitor.get("docker_container") or "")
+ if current_id == new_container_id:
+ return False
+
+ if dry_run:
+ logging.info(
+ "Dry-run: would update monitor %s docker_container from %s to %s",
+ monitor_id,
+ current_id,
+ new_container_id,
+ )
+ return False
+
+ last_error: Optional[Exception] = None
+
+ # Try minimal edit call patterns first.
+ for call in (
+ lambda: api.edit_monitor(monitor_id, docker_container=new_container_id),
+ lambda: api.edit_monitor(id=monitor_id, docker_container=new_container_id),
+ ):
+ try:
+ call()
+ logging.info(
+ "Updated monitor %s docker_container from %s to %s",
+ monitor_id,
+ current_id,
+ new_container_id,
+ )
+ return True
+ except Exception as exc: # noqa: BLE001
+ last_error = exc
+
+ if last_error is None:
+ raise RuntimeError(f"Failed to update monitor {monitor_id} for unknown reason")
+ raise RuntimeError(f"Failed to update monitor {monitor_id}: {last_error}")
+
+
+def _run_once(config: Dict[str, Any], mapping: Dict[str, Any]) -> None:
+ uptime_cfg = config.get("uptime_kuma") or {}
+ bot_cfg = config.get("bot") or {}
+
+ uptime_url = str(uptime_cfg.get("url") or "").strip()
+ api_key = str(uptime_cfg.get("api_key") or "").strip()
+ dry_run = bool(bot_cfg.get("dry_run", False))
+ timeout_seconds = int(bot_cfg.get("request_timeout_seconds", 10))
+
+ if not uptime_url:
+ raise ValueError("config.yml missing uptime_kuma.url")
+ if not api_key or api_key == "PUT_YOUR_API_KEY_HERE":
+ raise ValueError("config.yml missing real uptime_kuma.api_key")
+
+ mappings = mapping.get("mappings") or []
+ if not isinstance(mappings, list):
+ raise ValueError("container-monitor-map.yaml: mappings must be a list")
+
+ if not mappings:
+ logging.info("No mappings configured. Nothing to do.")
+ return
+
+ api = _api_login(uptime_url, api_key)
+ updated = 0
+
+ try:
+ for item in mappings:
+ if not isinstance(item, dict):
+ logging.warning("Skipping invalid mapping item (not a mapping): %r", item)
+ continue
+
+ if item.get("enabled", True) is False:
+ continue
+
+ name = str(item.get("name") or "unnamed")
+ host_api = str(item.get("host_api") or "").strip()
+ container_name = str(item.get("container_name") or "").strip()
+ expected_type = str(item.get("expected_uptime_type") or "").strip().lower()
+
+ monitor_id_raw = item.get("uptime_monitor_id")
+ try:
+ monitor_id = int(monitor_id_raw)
+ except Exception as exc: # noqa: BLE001
+ logging.error("[%s] Invalid uptime_monitor_id: %r (%s)", name, monitor_id_raw, exc)
+ continue
+
+ if not host_api or not container_name:
+ logging.error("[%s] Missing host_api or container_name", name)
+ continue
+
+ try:
+ container_id = _docker_get_container_id(host_api, container_name, timeout_seconds)
+ if not container_id:
+ continue
+
+ monitor = api.get_monitor(monitor_id)
+ monitor_type = str((monitor or {}).get("type") or "").lower()
+ if expected_type and monitor_type and monitor_type != expected_type:
+ logging.error(
+ "[%s] Monitor %s type mismatch. expected=%s actual=%s",
+ name,
+ monitor_id,
+ expected_type,
+ monitor_type,
+ )
+ continue
+
+ changed = _update_monitor_container_id(api, monitor_id, container_id, dry_run)
+ if changed:
+ updated += 1
+ except Exception as exc: # noqa: BLE001
+ logging.exception("[%s] Failed to process mapping: %s", name, exc)
+ finally:
+ try:
+ api.disconnect()
+ except Exception: # noqa: BLE001
+ pass
+
+ logging.info("Cycle complete. monitors_updated=%s", updated)
+
+
+def main() -> int:
+ signal.signal(signal.SIGINT, _signal_handler)
+ signal.signal(signal.SIGTERM, _signal_handler)
+
+ logging.basicConfig(
+ level=logging.INFO,
+ format="%(asctime)s %(levelname)s %(message)s",
+ )
+
+ if not os.path.exists(CONFIG_PATH):
+ logging.error("Missing config file: %s", CONFIG_PATH)
+ return 1
+ if not os.path.exists(MAP_PATH):
+ logging.error("Missing mapping file: %s", MAP_PATH)
+ return 1
+
+ config = _load_yaml(CONFIG_PATH)
+ mapping = _load_yaml(MAP_PATH)
+ bot_cfg = config.get("bot") or {}
+ interval_seconds = int(bot_cfg.get("poll_interval_seconds", 60))
+ if interval_seconds < 5:
+ logging.warning("poll_interval_seconds too low (%s), forcing to 5", interval_seconds)
+ interval_seconds = 5
+
+ logging.info("Starting uptime bot. interval=%ss", interval_seconds)
+
+ while not STOP:
+ try:
+ _run_once(config, mapping)
+ except Exception as exc: # noqa: BLE001
+ logging.exception("Cycle failed: %s", exc)
+
+ if STOP:
+ break
+
+ slept = 0
+ while slept < interval_seconds and not STOP:
+ time.sleep(1)
+ slept += 1
+
+ # Reload config/map each cycle so file changes apply without restart.
+ try:
+ config = _load_yaml(CONFIG_PATH)
+ mapping = _load_yaml(MAP_PATH)
+ bot_cfg = config.get("bot") or {}
+ new_interval = int(bot_cfg.get("poll_interval_seconds", interval_seconds))
+ interval_seconds = max(5, new_interval)
+ except Exception as exc: # noqa: BLE001
+ logging.warning("Failed to reload config/map, using previous values: %s", exc)
+
+ logging.info("Uptime bot stopped")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/uptime-updates/watchtower-export/Dockerfile b/uptime-updates/watchtower-export/Dockerfile
new file mode 100644
index 0000000..939ae53
--- /dev/null
+++ b/uptime-updates/watchtower-export/Dockerfile
@@ -0,0 +1,15 @@
+FROM python:3.12-alpine
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY uptime-bot.py /app/uptime-bot.py
+COPY config.yml /app/config.yml
+COPY container-monitor-map.yaml /app/container-monitor-map.yaml
+
+ENV UPTIME_BOT_CONFIG=/app/config.yml
+ENV UPTIME_BOT_MAP=/app/container-monitor-map.yaml
+
+CMD ["python", "/app/uptime-bot.py"]
diff --git a/uptime-updates/watchtower-export/README.md b/uptime-updates/watchtower-export/README.md
new file mode 100644
index 0000000..f3574df
--- /dev/null
+++ b/uptime-updates/watchtower-export/README.md
@@ -0,0 +1,50 @@
+# Watchtower Export Bundle
+
+This folder is a portable package with two Docker deployment modes:
+
+- Standalone bot + separate watchtower container
+- Embedded bot inside a custom watchtower image
+
+## Included Files
+
+- Dockerfile
+- docker-compose.watchtower-uptime-sync.yml
+- docker-compose.watchtower-embedded.yml
+- uptime-bot.py
+- requirements.txt
+- config.yml
+- container-monitor-map.yaml
+- watchtower-embedded/Dockerfile.watchtower-with-uptime-bot
+- watchtower-embedded/start-watchtower-with-uptime-bot.sh
+
+## Create Export Tarball
+
+From uptime-updates directory:
+
+```bash
+bash export-watchtower-bundle.sh
+```
+
+This creates a timestamped tar.gz in this folder.
+
+## Run Standalone Mode (Recommended)
+
+In this folder:
+
+```bash
+docker compose -f docker-compose.watchtower-uptime-sync.yml up -d --build
+```
+
+## Run Embedded Watchtower Mode
+
+In this folder:
+
+```bash
+docker compose -f docker-compose.watchtower-embedded.yml up -d --build
+```
+
+## Notes
+
+- The bot uses Docker host API endpoints listed in container-monitor-map.yaml.
+- Keep config.yml and container-monitor-map.yaml updated with your real values.
+- These Docker deployments do not require systemd.
diff --git a/uptime-updates/watchtower-export/config.yml b/uptime-updates/watchtower-export/config.yml
new file mode 100644
index 0000000..7ad8638
--- /dev/null
+++ b/uptime-updates/watchtower-export/config.yml
@@ -0,0 +1,9 @@
+uptime_kuma:
+ url: "http://127.0.0.1:3001"
+ api_key: "PUT_YOUR_API_KEY_HERE"
+
+# Optional bot behavior settings
+bot:
+ dry_run: false
+ request_timeout_seconds: 10
+ poll_interval_seconds: 60
diff --git a/uptime-updates/watchtower-export/container-monitor-map.yaml b/uptime-updates/watchtower-export/container-monitor-map.yaml
new file mode 100644
index 0000000..0d12108
--- /dev/null
+++ b/uptime-updates/watchtower-export/container-monitor-map.yaml
@@ -0,0 +1,43 @@
+# Container to Uptime Kuma monitor mapping
+#
+# Fill in one item per container you want tracked.
+# The bot can read this file to know:
+# 1) which Docker host to query
+# 2) which container on that host to watch
+# 3) which Uptime Kuma monitor to update when container ID changes
+#
+# Notes:
+# - uptime_monitor_id is the numeric ID in Uptime Kuma.
+# You can get it from the monitor URL, e.g. /dashboard/42 -> 42
+# - host_api should be the Docker API endpoint for that host.
+# Example: tcp://10.0.84.21:2375
+# - container_name should match docker container name used by that host.
+#
+# Optional fields:
+# - enabled: true/false (default true)
+# - expected_uptime_type: set to "docker" to protect against wrong monitor type updates
+
+mappings:
+ - name: "media-server jellyfin"
+ enabled: true
+ host_label: "media-server"
+ host_api: "tcp://10.0.84.21:2375"
+ container_name: "jellyfin"
+ uptime_monitor_id: 21
+ expected_uptime_type: "docker"
+
+ - name: "nas immich"
+ enabled: true
+ host_label: "nas"
+ host_api: "tcp://10.0.84.22:2375"
+ container_name: "immich-server"
+ uptime_monitor_id: 34
+ expected_uptime_type: "docker"
+
+ - name: "lab pihole"
+ enabled: false
+ host_label: "lab"
+ host_api: "tcp://10.0.84.30:2375"
+ container_name: "pihole"
+ uptime_monitor_id: 56
+ expected_uptime_type: "docker"
diff --git a/uptime-updates/watchtower-export/docker-compose.watchtower-embedded.yml b/uptime-updates/watchtower-export/docker-compose.watchtower-embedded.yml
new file mode 100644
index 0000000..7ebdc56
--- /dev/null
+++ b/uptime-updates/watchtower-export/docker-compose.watchtower-embedded.yml
@@ -0,0 +1,14 @@
+version: "3.8"
+
+services:
+ watchtower-with-uptime-bot:
+ build:
+ context: .
+ dockerfile: watchtower-embedded/Dockerfile.watchtower-with-uptime-bot
+ container_name: watchtower-with-uptime-bot
+ restart: unless-stopped
+ volumes:
+ - /var/run/docker.sock:/var/run/docker.sock
+ - ./config.yml:/opt/uptime-bot/config.yml:ro
+ - ./container-monitor-map.yaml:/opt/uptime-bot/container-monitor-map.yaml:ro
+ command: --interval 300 --cleanup
diff --git a/uptime-updates/watchtower-export/docker-compose.watchtower-uptime-sync.yml b/uptime-updates/watchtower-export/docker-compose.watchtower-uptime-sync.yml
new file mode 100644
index 0000000..215e34d
--- /dev/null
+++ b/uptime-updates/watchtower-export/docker-compose.watchtower-uptime-sync.yml
@@ -0,0 +1,23 @@
+version: "3.8"
+
+services:
+ watchtower:
+ image: containrrr/watchtower:latest
+ container_name: watchtower
+ restart: unless-stopped
+ volumes:
+ - /var/run/docker.sock:/var/run/docker.sock
+ command: --interval 300 --cleanup
+
+ uptime-sync-bot:
+ build:
+ context: .
+ dockerfile: Dockerfile
+ container_name: uptime-sync-bot
+ restart: unless-stopped
+ volumes:
+ - ./config.yml:/app/config.yml:ro
+ - ./container-monitor-map.yaml:/app/container-monitor-map.yaml:ro
+ environment:
+ - UPTIME_BOT_CONFIG=/app/config.yml
+ - UPTIME_BOT_MAP=/app/container-monitor-map.yaml
diff --git a/uptime-updates/watchtower-export/requirements.txt b/uptime-updates/watchtower-export/requirements.txt
new file mode 100644
index 0000000..ecc9577
--- /dev/null
+++ b/uptime-updates/watchtower-export/requirements.txt
@@ -0,0 +1,2 @@
+uptime-kuma-api>=1.2.1
+PyYAML>=6.0
diff --git a/uptime-updates/watchtower-export/uptime-bot.py b/uptime-updates/watchtower-export/uptime-bot.py
new file mode 100644
index 0000000..bb6afb3
--- /dev/null
+++ b/uptime-updates/watchtower-export/uptime-bot.py
@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Continuously sync Docker container IDs into Uptime Kuma docker monitors.
+
+This bot reads:
+- config.yml
+- container-monitor-map.yaml
+
+From the same directory as this script.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+import yaml
+from uptime_kuma_api import UptimeKumaApi
+
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_PATH = os.getenv("UPTIME_BOT_CONFIG", os.path.join(BASE_DIR, "config.yml"))
+MAP_PATH = os.getenv("UPTIME_BOT_MAP", os.path.join(BASE_DIR, "container-monitor-map.yaml"))
+
+STOP = False
+
+
+def _signal_handler(signum: int, _frame: Any) -> None:
+ global STOP
+ STOP = True
+ logging.info("Received signal %s, shutting down...", signum)
+
+
+def _load_yaml(path: str) -> Dict[str, Any]:
+ with open(path, "r", encoding="utf-8") as handle:
+ data = yaml.safe_load(handle) or {}
+ if not isinstance(data, dict):
+ raise ValueError(f"YAML root in {path} must be a mapping")
+ return data
+
+
+def _normalize_docker_host_url(raw_url: str) -> str:
+ if raw_url.startswith("tcp://"):
+ return "http://" + raw_url[len("tcp://") :]
+ if raw_url.startswith("http://") or raw_url.startswith("https://"):
+ return raw_url
+ raise ValueError(f"Unsupported host_api scheme: {raw_url}")
+
+
+def _docker_get_container_id(host_api: str, container_name: str, timeout_seconds: int) -> Optional[str]:
+ """Resolve a container name on a Docker host to its full container ID.
+
+ Uses Docker remote API endpoint: /containers/{name}/json
+ """
+ base_url = _normalize_docker_host_url(host_api).rstrip("/")
+ encoded_name = urllib.parse.quote(container_name, safe="")
+ url = f"{base_url}/containers/{encoded_name}/json"
+
+ request = urllib.request.Request(url=url, method="GET", headers={"Accept": "application/json"})
+
+ try:
+ with urllib.request.urlopen(request, timeout=timeout_seconds) as response:
+ payload = json.loads(response.read().decode("utf-8"))
+ except urllib.error.HTTPError as exc:
+ if exc.code == 404:
+ logging.warning("Container not found on host %s: %s", host_api, container_name)
+ return None
+ raise
+
+ container_id = payload.get("Id")
+ if not container_id:
+ raise RuntimeError(f"Docker API response missing Id for {container_name} on {host_api}")
+ return str(container_id)
+
+
+def _api_login(url: str, api_key: str) -> UptimeKumaApi:
+ api = UptimeKumaApi(url)
+ # Uptime Kuma API key auth in wrapper is login_by_token.
+ api.login_by_token(api_key)
+ return api
+
+
+def _update_monitor_container_id(
+ api: UptimeKumaApi,
+ monitor_id: int,
+ new_container_id: str,
+ dry_run: bool,
+) -> bool:
+ """Attempt to update docker_container for a monitor.
+
+ Returns True if monitor was updated, False if unchanged or dry-run.
+ """
+ monitor = api.get_monitor(monitor_id)
+ if not isinstance(monitor, dict):
+ raise RuntimeError(f"Unexpected monitor payload for id {monitor_id}: {type(monitor)}")
+
+ current_id = str(monitor.get("docker_container") or "")
+ if current_id == new_container_id:
+ return False
+
+ if dry_run:
+ logging.info(
+ "Dry-run: would update monitor %s docker_container from %s to %s",
+ monitor_id,
+ current_id,
+ new_container_id,
+ )
+ return False
+
+ last_error: Optional[Exception] = None
+
+ # Try minimal edit call patterns first.
+ for call in (
+ lambda: api.edit_monitor(monitor_id, docker_container=new_container_id),
+ lambda: api.edit_monitor(id=monitor_id, docker_container=new_container_id),
+ ):
+ try:
+ call()
+ logging.info(
+ "Updated monitor %s docker_container from %s to %s",
+ monitor_id,
+ current_id,
+ new_container_id,
+ )
+ return True
+ except Exception as exc: # noqa: BLE001
+ last_error = exc
+
+ if last_error is None:
+ raise RuntimeError(f"Failed to update monitor {monitor_id} for unknown reason")
+ raise RuntimeError(f"Failed to update monitor {monitor_id}: {last_error}")
+
+
+def _run_once(config: Dict[str, Any], mapping: Dict[str, Any]) -> None:
+ uptime_cfg = config.get("uptime_kuma") or {}
+ bot_cfg = config.get("bot") or {}
+
+ uptime_url = str(uptime_cfg.get("url") or "").strip()
+ api_key = str(uptime_cfg.get("api_key") or "").strip()
+ dry_run = bool(bot_cfg.get("dry_run", False))
+ timeout_seconds = int(bot_cfg.get("request_timeout_seconds", 10))
+
+ if not uptime_url:
+ raise ValueError("config.yml missing uptime_kuma.url")
+ if not api_key or api_key == "PUT_YOUR_API_KEY_HERE":
+ raise ValueError("config.yml missing real uptime_kuma.api_key")
+
+ mappings = mapping.get("mappings") or []
+ if not isinstance(mappings, list):
+ raise ValueError("container-monitor-map.yaml: mappings must be a list")
+
+ if not mappings:
+ logging.info("No mappings configured. Nothing to do.")
+ return
+
+ api = _api_login(uptime_url, api_key)
+ updated = 0
+
+ try:
+ for item in mappings:
+ if not isinstance(item, dict):
+ logging.warning("Skipping invalid mapping item (not a mapping): %r", item)
+ continue
+
+ if item.get("enabled", True) is False:
+ continue
+
+ name = str(item.get("name") or "unnamed")
+ host_api = str(item.get("host_api") or "").strip()
+ container_name = str(item.get("container_name") or "").strip()
+ expected_type = str(item.get("expected_uptime_type") or "").strip().lower()
+
+ monitor_id_raw = item.get("uptime_monitor_id")
+ try:
+ monitor_id = int(monitor_id_raw)
+ except Exception as exc: # noqa: BLE001
+ logging.error("[%s] Invalid uptime_monitor_id: %r (%s)", name, monitor_id_raw, exc)
+ continue
+
+ if not host_api or not container_name:
+ logging.error("[%s] Missing host_api or container_name", name)
+ continue
+
+ try:
+ container_id = _docker_get_container_id(host_api, container_name, timeout_seconds)
+ if not container_id:
+ continue
+
+ monitor = api.get_monitor(monitor_id)
+ monitor_type = str((monitor or {}).get("type") or "").lower()
+ if expected_type and monitor_type and monitor_type != expected_type:
+ logging.error(
+ "[%s] Monitor %s type mismatch. expected=%s actual=%s",
+ name,
+ monitor_id,
+ expected_type,
+ monitor_type,
+ )
+ continue
+
+ changed = _update_monitor_container_id(api, monitor_id, container_id, dry_run)
+ if changed:
+ updated += 1
+ except Exception as exc: # noqa: BLE001
+ logging.exception("[%s] Failed to process mapping: %s", name, exc)
+ finally:
+ try:
+ api.disconnect()
+ except Exception: # noqa: BLE001
+ pass
+
+ logging.info("Cycle complete. monitors_updated=%s", updated)
+
+
+def main() -> int:
+ signal.signal(signal.SIGINT, _signal_handler)
+ signal.signal(signal.SIGTERM, _signal_handler)
+
+ logging.basicConfig(
+ level=logging.INFO,
+ format="%(asctime)s %(levelname)s %(message)s",
+ )
+
+ if not os.path.exists(CONFIG_PATH):
+ logging.error("Missing config file: %s", CONFIG_PATH)
+ return 1
+ if not os.path.exists(MAP_PATH):
+ logging.error("Missing mapping file: %s", MAP_PATH)
+ return 1
+
+ config = _load_yaml(CONFIG_PATH)
+ mapping = _load_yaml(MAP_PATH)
+ bot_cfg = config.get("bot") or {}
+ interval_seconds = int(bot_cfg.get("poll_interval_seconds", 60))
+ if interval_seconds < 5:
+ logging.warning("poll_interval_seconds too low (%s), forcing to 5", interval_seconds)
+ interval_seconds = 5
+
+ logging.info("Starting uptime bot. interval=%ss", interval_seconds)
+
+ while not STOP:
+ try:
+ _run_once(config, mapping)
+ except Exception as exc: # noqa: BLE001
+ logging.exception("Cycle failed: %s", exc)
+
+ if STOP:
+ break
+
+ slept = 0
+ while slept < interval_seconds and not STOP:
+ time.sleep(1)
+ slept += 1
+
+ # Reload config/map each cycle so file changes apply without restart.
+ try:
+ config = _load_yaml(CONFIG_PATH)
+ mapping = _load_yaml(MAP_PATH)
+ bot_cfg = config.get("bot") or {}
+ new_interval = int(bot_cfg.get("poll_interval_seconds", interval_seconds))
+ interval_seconds = max(5, new_interval)
+ except Exception as exc: # noqa: BLE001
+ logging.warning("Failed to reload config/map, using previous values: %s", exc)
+
+ logging.info("Uptime bot stopped")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/uptime-updates/watchtower-export/uptime-watchtower-bundle-20260411-210346.tar.gz b/uptime-updates/watchtower-export/uptime-watchtower-bundle-20260411-210346.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..90e4dd76ecbd6eb8ac6d499c7c7595dbb05fd969
GIT binary patch
literal 5190
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
A-T(jq
literal 0
HcmV?d00001
diff --git a/uptime-updates/watchtower-export/uptime-watchtower-bundle-20260411-211129.tar.gz b/uptime-updates/watchtower-export/uptime-watchtower-bundle-20260411-211129.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f6798a08ce66c886173a0e40e3db1b98404db32d
GIT binary patch
literal 6221
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
literal 0
HcmV?d00001
diff --git a/uptime-updates/watchtower-export/watchtower-embedded/Dockerfile.watchtower-with-uptime-bot b/uptime-updates/watchtower-export/watchtower-embedded/Dockerfile.watchtower-with-uptime-bot
new file mode 100644
index 0000000..0280288
--- /dev/null
+++ b/uptime-updates/watchtower-export/watchtower-embedded/Dockerfile.watchtower-with-uptime-bot
@@ -0,0 +1,23 @@
+FROM containrrr/watchtower:latest
+
+USER root
+
+RUN apk add --no-cache python3 py3-pip
+
+WORKDIR /opt/uptime-bot
+
+COPY requirements.txt /opt/uptime-bot/requirements.txt
+RUN pip3 install --no-cache-dir -r /opt/uptime-bot/requirements.txt
+
+COPY uptime-bot.py /opt/uptime-bot/uptime-bot.py
+COPY config.yml /opt/uptime-bot/config.yml
+COPY container-monitor-map.yaml /opt/uptime-bot/container-monitor-map.yaml
+COPY watchtower-embedded/start-watchtower-with-uptime-bot.sh /usr/local/bin/start-watchtower-with-uptime-bot.sh
+
+RUN chmod +x /usr/local/bin/start-watchtower-with-uptime-bot.sh
+
+ENV UPTIME_BOT_CONFIG=/opt/uptime-bot/config.yml
+ENV UPTIME_BOT_MAP=/opt/uptime-bot/container-monitor-map.yaml
+
+ENTRYPOINT ["/usr/local/bin/start-watchtower-with-uptime-bot.sh"]
+CMD ["--interval", "300", "--cleanup"]
diff --git a/uptime-updates/watchtower-export/watchtower-embedded/start-watchtower-with-uptime-bot.sh b/uptime-updates/watchtower-export/watchtower-embedded/start-watchtower-with-uptime-bot.sh
new file mode 100644
index 0000000..6e2b311
--- /dev/null
+++ b/uptime-updates/watchtower-export/watchtower-embedded/start-watchtower-with-uptime-bot.sh
@@ -0,0 +1,50 @@
+#!/bin/sh
+set -eu
+
+BOT_SCRIPT="/opt/uptime-bot/uptime-bot.py"
+WATCHTOWER_BIN="/watchtower"
+
+if [ ! -x "${WATCHTOWER_BIN}" ]; then
+ echo "[ERROR] watchtower binary not found at ${WATCHTOWER_BIN}" >&2
+ exit 1
+fi
+
+if [ ! -f "${BOT_SCRIPT}" ]; then
+ echo "[ERROR] bot script not found at ${BOT_SCRIPT}" >&2
+ exit 1
+fi
+
+python3 "${BOT_SCRIPT}" &
+BOT_PID=$!
+
+"${WATCHTOWER_BIN}" "$@" &
+WT_PID=$!
+
+shutdown() {
+ kill "${BOT_PID}" 2>/dev/null || true
+ kill "${WT_PID}" 2>/dev/null || true
+ wait "${BOT_PID}" 2>/dev/null || true
+ wait "${WT_PID}" 2>/dev/null || true
+}
+
+trap shutdown INT TERM
+
+while :; do
+ if ! kill -0 "${BOT_PID}" 2>/dev/null; then
+ echo "[ERROR] uptime bot exited; stopping watchtower" >&2
+ kill "${WT_PID}" 2>/dev/null || true
+ wait "${WT_PID}" 2>/dev/null || true
+ wait "${BOT_PID}" 2>/dev/null || true
+ exit 1
+ fi
+
+ if ! kill -0 "${WT_PID}" 2>/dev/null; then
+ echo "[ERROR] watchtower exited; stopping uptime bot" >&2
+ kill "${BOT_PID}" 2>/dev/null || true
+ wait "${BOT_PID}" 2>/dev/null || true
+ wait "${WT_PID}" 2>/dev/null || true
+ exit 1
+ fi
+
+ sleep 2
+done