478 lines
14 KiB
Python
478 lines
14 KiB
Python
from pathlib import Path
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import re
|
|
import threading
|
|
import time
|
|
|
|
import httpx
|
|
import websockets
|
|
|
|
|
|
UPDATE_STATE = Path("/config/homecore_update.json")
|
|
SUPERVISOR = "http://supervisor"
|
|
|
|
|
|
def version_tuple(value):
|
|
parts = re.findall(r"\d+", str(value))
|
|
return tuple(int(x) for x in parts[:4])
|
|
|
|
|
|
def load_update_state():
|
|
try:
|
|
return json.loads(UPDATE_STATE.read_text())
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def save_update_state(data):
|
|
UPDATE_STATE.write_text(json.dumps(data, indent=2))
|
|
|
|
|
|
def supervisor_headers():
|
|
token = os.getenv("SUPERVISOR_TOKEN")
|
|
if not token:
|
|
raise RuntimeError("SUPERVISOR_TOKEN is not available")
|
|
return {
|
|
"Authorization": "Bearer " + token,
|
|
"Content-Type": "application/json",
|
|
}
|
|
|
|
|
|
def supervisor_request(method, path, payload=None, timeout=90):
|
|
r = httpx.request(
|
|
method,
|
|
SUPERVISOR + path,
|
|
headers=supervisor_headers(),
|
|
json=payload,
|
|
timeout=timeout,
|
|
)
|
|
r.raise_for_status()
|
|
|
|
try:
|
|
body = r.json()
|
|
except Exception:
|
|
return {}
|
|
|
|
if isinstance(body, dict):
|
|
if body.get("result") == "error":
|
|
raise RuntimeError(body.get("message") or "Supervisor error")
|
|
if "data" in body:
|
|
return body["data"]
|
|
|
|
return body
|
|
|
|
|
|
HOME_ASSISTANT_WEBSOCKET = "ws://supervisor/core/websocket"
|
|
|
|
|
|
async def _homeassistant_update_app_async(slug, backup=True):
|
|
token = os.getenv("SUPERVISOR_TOKEN")
|
|
if not token:
|
|
raise RuntimeError("SUPERVISOR_TOKEN is not available")
|
|
|
|
async with websockets.connect(
|
|
HOME_ASSISTANT_WEBSOCKET,
|
|
open_timeout=20,
|
|
close_timeout=5,
|
|
ping_interval=None,
|
|
) as ws:
|
|
first = json.loads(await asyncio.wait_for(ws.recv(), timeout=20))
|
|
if first.get("type") != "auth_required":
|
|
raise RuntimeError(
|
|
"Unexpected Home Assistant WebSocket greeting: "
|
|
+ str(first.get("type"))
|
|
)
|
|
|
|
await ws.send(
|
|
json.dumps(
|
|
{
|
|
"type": "auth",
|
|
"access_token": token,
|
|
}
|
|
)
|
|
)
|
|
|
|
auth = json.loads(await asyncio.wait_for(ws.recv(), timeout=20))
|
|
if auth.get("type") != "auth_ok":
|
|
raise RuntimeError(
|
|
"Home Assistant WebSocket authentication failed: "
|
|
+ str(auth.get("message") or auth.get("type"))
|
|
)
|
|
|
|
command_id = 1
|
|
await ws.send(
|
|
json.dumps(
|
|
{
|
|
"id": command_id,
|
|
"type": "hassio/update/addon",
|
|
"addon": slug,
|
|
"backup": bool(backup),
|
|
}
|
|
)
|
|
)
|
|
|
|
result = json.loads(await asyncio.wait_for(ws.recv(), timeout=300))
|
|
|
|
if result.get("id") != command_id:
|
|
raise RuntimeError(
|
|
"Unexpected Home Assistant update response ID"
|
|
)
|
|
|
|
if not result.get("success"):
|
|
error = result.get("error") or {}
|
|
raise RuntimeError(
|
|
str(error.get("message") or error or "Home Assistant update failed")
|
|
)
|
|
|
|
|
|
def homeassistant_update_app(slug, backup=True):
|
|
"""
|
|
Ask Home Assistant Core to update this app.
|
|
|
|
Calling Supervisor's /store/addons/<slug>/update endpoint directly from
|
|
the app is blocked because an app cannot update itself. Home Assistant
|
|
Core exposes the admin WebSocket command hassio/update/addon specifically
|
|
for normal app updates. The Supervisor proxy authenticates this app using
|
|
SUPERVISOR_TOKEN.
|
|
"""
|
|
return asyncio.run(
|
|
_homeassistant_update_app_async(slug, backup=backup)
|
|
)
|
|
|
|
|
|
|
|
def find_homecore_app():
|
|
data = supervisor_request("GET", "/store/addons")
|
|
|
|
if isinstance(data, dict):
|
|
apps = data.get("addons", [])
|
|
else:
|
|
apps = data or []
|
|
|
|
candidates = []
|
|
for app in apps:
|
|
slug = str(app.get("slug", ""))
|
|
name = str(app.get("name", ""))
|
|
if (
|
|
name == "HomeCore Controller"
|
|
or slug == "homecore_controller"
|
|
or slug.endswith("_homecore_controller")
|
|
):
|
|
candidates.append(app)
|
|
|
|
if not candidates:
|
|
raise RuntimeError(
|
|
"HomeCore Controller was not found in the Home Assistant App store"
|
|
)
|
|
|
|
installed = [x for x in candidates if x.get("installed")]
|
|
return (installed or candidates)[0]
|
|
|
|
|
|
class HomeCoreUpdateManager:
|
|
"""
|
|
Manual, per-controller update manager.
|
|
|
|
The manager never asks for a global/latest release. It polls only for a
|
|
command addressed to this controller. A command exists only after an
|
|
administrator presses Install Update for that controller in HomeCore Admin.
|
|
Failed updates are not retried automatically.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
current_version,
|
|
cloud_api_fn,
|
|
load_controller_state,
|
|
controller_session_fn,
|
|
):
|
|
self.current_version = current_version
|
|
self.cloud_api_fn = cloud_api_fn
|
|
self.load_controller_state = load_controller_state
|
|
self.controller_session_fn = controller_session_fn
|
|
self.last_report = None
|
|
|
|
def cloud_api(self):
|
|
return self.cloud_api_fn()["cloud_api"].rstrip("/")
|
|
|
|
def report(self, status, request_id="", target_version="", detail=""):
|
|
key = (status, request_id, target_version, detail)
|
|
if key == self.last_report:
|
|
return
|
|
self.last_report = key
|
|
|
|
print(
|
|
f"HOMECORE UPDATE: {status} "
|
|
f"request={request_id or '-'} "
|
|
f"current={self.current_version} "
|
|
f"target={target_version or '-'} "
|
|
f"{detail}",
|
|
flush=True,
|
|
)
|
|
|
|
state = self.load_controller_state()
|
|
controller_id = state.get("controller_id")
|
|
if not controller_id:
|
|
return
|
|
|
|
try:
|
|
token = self.controller_session_fn()
|
|
httpx.post(
|
|
self.cloud_api()
|
|
+ f"/api/v1/controllers/{controller_id}/update-status",
|
|
headers={"Authorization": "Bearer " + token},
|
|
json={
|
|
"request_id": request_id,
|
|
"status": status,
|
|
"target_version": target_version,
|
|
"current_version": self.current_version,
|
|
"detail": detail,
|
|
},
|
|
timeout=15,
|
|
).raise_for_status()
|
|
except Exception as exc:
|
|
print("HOMECORE UPDATE: status report failed:", exc, flush=True)
|
|
|
|
def update_command(self):
|
|
state = self.load_controller_state()
|
|
controller_id = state.get("controller_id")
|
|
if not controller_id:
|
|
return None
|
|
|
|
token = self.controller_session_fn()
|
|
r = httpx.get(
|
|
self.cloud_api()
|
|
+ f"/api/v1/controllers/{controller_id}/update-command",
|
|
headers={"Authorization": "Bearer " + token},
|
|
timeout=15,
|
|
)
|
|
r.raise_for_status()
|
|
body = r.json()
|
|
return body.get("command") if isinstance(body, dict) else None
|
|
|
|
def mark_completed_if_required(self):
|
|
st = load_update_state()
|
|
request_id = str(st.get("request_id", ""))
|
|
target = str(st.get("target_version", ""))
|
|
|
|
if (
|
|
request_id
|
|
and target
|
|
and target == self.current_version
|
|
and st.get("status") == "installing"
|
|
):
|
|
self.report(
|
|
"completed",
|
|
request_id,
|
|
target,
|
|
"HomeCore Controller update completed successfully",
|
|
)
|
|
save_update_state(
|
|
{
|
|
**st,
|
|
"status": "completed",
|
|
"completed_at": int(time.time()),
|
|
}
|
|
)
|
|
|
|
def check_once(self):
|
|
command = self.update_command()
|
|
if not command:
|
|
return
|
|
|
|
request_id = str(command.get("request_id", "")).strip()
|
|
target = str(command.get("target_version", "")).strip()
|
|
if not request_id or not target:
|
|
raise RuntimeError("HomeCore Cloud returned an incomplete update command")
|
|
|
|
previous = load_update_state()
|
|
if (
|
|
str(previous.get("request_id", "")) == request_id
|
|
and previous.get("status") == "installing"
|
|
):
|
|
# Supervisor already accepted this exact request. Wait for the app
|
|
# restart rather than ever issuing the update a second time.
|
|
return
|
|
|
|
if target == self.current_version:
|
|
self.report(
|
|
"completed",
|
|
request_id,
|
|
target,
|
|
"Controller already has the requested HomeCore version",
|
|
)
|
|
save_update_state(
|
|
{
|
|
"status": "completed",
|
|
"request_id": request_id,
|
|
"target_version": target,
|
|
"completed_at": int(time.time()),
|
|
}
|
|
)
|
|
return
|
|
|
|
if version_tuple(target) < version_tuple(self.current_version):
|
|
raise RuntimeError(
|
|
"Automatic downgrade is not supported; controller has "
|
|
+ self.current_version
|
|
+ " and request targets "
|
|
+ target
|
|
)
|
|
|
|
self.report(
|
|
"preparing",
|
|
request_id,
|
|
target,
|
|
"Manual HomeCore Admin update request received",
|
|
)
|
|
|
|
supervisor_request("POST", "/store/reload")
|
|
time.sleep(3)
|
|
|
|
app = find_homecore_app()
|
|
slug = str(app.get("slug", ""))
|
|
# Home Assistant Supervisor reports:
|
|
# version = installed app version
|
|
# version_latest = newest version offered by the repository
|
|
#
|
|
# Always compare the Admin target against version_latest first.
|
|
repository_version = str(
|
|
app.get("version_latest")
|
|
or app.get("version_available")
|
|
or app.get("version")
|
|
or ""
|
|
)
|
|
|
|
print(
|
|
"HOMECORE UPDATE: repository check "
|
|
f"installed={app.get('version') or '-'} "
|
|
f"latest={app.get('version_latest') or '-'} "
|
|
f"target={target}",
|
|
flush=True,
|
|
)
|
|
|
|
installed_field = app.get("installed")
|
|
installed_version = (
|
|
installed_field
|
|
if isinstance(installed_field, str)
|
|
else self.current_version
|
|
)
|
|
|
|
if not slug:
|
|
raise RuntimeError("HomeCore App slug could not be determined")
|
|
|
|
if repository_version != target:
|
|
self.report(
|
|
"waiting_repository",
|
|
request_id,
|
|
target,
|
|
"Home Assistant repository currently offers "
|
|
+ (repository_version or "no version"),
|
|
)
|
|
save_update_state(
|
|
{
|
|
"status": "waiting_repository",
|
|
"request_id": request_id,
|
|
"target_version": target,
|
|
"repository_version": repository_version,
|
|
"checked_at": int(time.time()),
|
|
}
|
|
)
|
|
return
|
|
|
|
supervisor_request("GET", f"/store/addons/{slug}/availability")
|
|
|
|
state = {
|
|
"status": "installing",
|
|
"request_id": request_id,
|
|
"target_version": target,
|
|
"installed_version": installed_version,
|
|
"repository_version": repository_version,
|
|
"slug": slug,
|
|
"attempted_at": int(time.time()),
|
|
}
|
|
save_update_state(state)
|
|
|
|
self.report(
|
|
"installing",
|
|
request_id,
|
|
target,
|
|
"Backup requested; Home Assistant Core app update starting",
|
|
)
|
|
|
|
print(
|
|
"HOMECORE UPDATE: Home Assistant WebSocket update "
|
|
f"slug={slug} target={target}",
|
|
flush=True,
|
|
)
|
|
|
|
# Home Assistant Supervisor blocks an app from calling its own
|
|
# /store/addons/<slug>/update endpoint directly. Route the request
|
|
# through Home Assistant Core's admin WebSocket command instead.
|
|
# Core then performs the normal Supervisor app update on our behalf.
|
|
homeassistant_update_app(slug, backup=True)
|
|
|
|
print(
|
|
"HOMECORE UPDATE: Home Assistant accepted manual app update",
|
|
flush=True,
|
|
)
|
|
|
|
def run(self):
|
|
self.mark_completed_if_required()
|
|
|
|
while True:
|
|
try:
|
|
self.check_once()
|
|
except Exception as exc:
|
|
st = load_update_state()
|
|
request_id = str(st.get("request_id", ""))
|
|
target = str(st.get("target_version", ""))
|
|
|
|
# If the failure happened before state was written, attempt to
|
|
# recover the active command once for accurate reporting.
|
|
if not request_id:
|
|
try:
|
|
cmd = self.update_command() or {}
|
|
request_id = str(cmd.get("request_id", ""))
|
|
target = str(cmd.get("target_version", ""))
|
|
except Exception:
|
|
pass
|
|
|
|
failed_state = {
|
|
**st,
|
|
"status": "failed",
|
|
"request_id": request_id,
|
|
"target_version": target,
|
|
"detail": str(exc),
|
|
"failed_at": int(time.time()),
|
|
}
|
|
save_update_state(failed_state)
|
|
self.report("failed", request_id, target, str(exc))
|
|
|
|
# No automatic retry. The cloud suppresses a failed request;
|
|
# Admin must explicitly create a new request by pressing Install.
|
|
|
|
time.sleep(30)
|
|
|
|
|
|
def start_update_manager(
|
|
current_version,
|
|
cloud_api_fn,
|
|
load_controller_state,
|
|
controller_session_fn,
|
|
):
|
|
manager = HomeCoreUpdateManager(
|
|
current_version=current_version,
|
|
cloud_api_fn=cloud_api_fn,
|
|
load_controller_state=load_controller_state,
|
|
controller_session_fn=controller_session_fn,
|
|
)
|
|
|
|
threading.Thread(
|
|
target=manager.run,
|
|
daemon=True,
|
|
name="homecore-update-manager",
|
|
).start()
|