261 lines
11 KiB
Python
Executable File
261 lines
11 KiB
Python
Executable File
#!/usr/bin/python
|
||
# SPDX-License-Identifier: MIT
|
||
"""Záloha companionu (L1, karta) přes companion protokol PŘED flashem.
|
||
|
||
tools/companion_backup.py /dev/serial/by-id/usb-...L1... L1-pre-flash
|
||
tools/companion_backup.py <port> <jméno> --diff ~/.local/share/meshcore-backups/<starší>.json
|
||
tools/companion_backup.py <BLE MAC> <jméno> # místo portu MAC = přes BLE (bond nutný)
|
||
|
||
Uloží self_info (jméno, rádio, poloha, path hash…), device query, custom vars,
|
||
kontakty a kanály do ~/.local/share/meshcore-backups/<jméno>-<datum>.json (0600 —
|
||
jsou v tom klíče kanálů). Na stdout nic tajného, jen souhrn; `--diff` porovná se
|
||
starší zálohou (po flashi), klíče kanálů porovnává jen jako shodu.
|
||
|
||
Solo navíc vystavuje nastavení přes companion CLI (`keys`, `get`, `set`;
|
||
ui-core/SettingsCli.h): záloha je uloží všechna do sekce `cli` a `--restore`
|
||
je vrátí. Live Share cíl/zapnutí/scope (`share.to`, `share.on`, `share.scope`)
|
||
umí CLI až od solo-tth s tímhle doplňkem — 16. 10. 2026 po v2.0 skončil Live
|
||
Share na kanálu Public a nebylo jak to zjistit. Co CLI nezná (bot, část UI),
|
||
musí po flashi zkontrolovat člověk na zařízení.
|
||
|
||
Hodiny flash nepřežijí (L1 22. 10. 2026 po v2.0.1 o 10 h pozadu), proto
|
||
`--diff` (= běh po flashi) a samostatné `--sync-time` nastaví čas hostu
|
||
(CMD_SET_DEVICE_TIME — lokální příkaz po USB, nic nevysílá). Firmware čas
|
||
dozadu odmítne; uzel napřed se jen ohlásí.
|
||
|
||
tools/companion_backup.py <port> L1-post --restore <záloha>.json # jen ukáže
|
||
tools/companion_backup.py <port> L1-post --restore <záloha>.json --apply # zapíše
|
||
|
||
`--restore` Live Share nikdy NEZAPNE (to je vysílání do meshe) — jen vypne,
|
||
když bylo v záloze vypnuté; zapnout ho je na člověku. Privátní klíč přes USB náš firmware nevydá
|
||
(`private_key_export_disabled`), záloha identity je ve vaultu (keys.yml).
|
||
|
||
Spouští se interpretem meshcli (#!/usr/bin/python), tam je knihovna meshcore.
|
||
Knihovna shazuje DTR a L1 bez DTR na USB mlčí ⇒ _dtr_on() + cx_dly=1,5 s.
|
||
Když je k L1 připojený telefon přes BLE, USB mlčí — vypni na telefonu BT.
|
||
"""
|
||
import argparse
|
||
import asyncio
|
||
import datetime as dt
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
import time
|
||
|
||
if {"-h", "--help"} & set(sys.argv[1:]):
|
||
print(__doc__.strip())
|
||
sys.exit(0)
|
||
|
||
from meshcore import EventType, MeshCore # noqa: E402
|
||
|
||
DIR = os.path.expanduser("~/.local/share/meshcore-backups")
|
||
|
||
|
||
def plain(x):
|
||
if isinstance(x, (bytes, bytearray)):
|
||
return x.hex()
|
||
if isinstance(x, dict):
|
||
return {str(k): plain(v) for k, v in x.items()}
|
||
if isinstance(x, (list, tuple)):
|
||
return [plain(v) for v in x]
|
||
return x
|
||
|
||
|
||
def _dtr_on():
|
||
"""Knihovna meshcore po otevření portu SHAZUJE DTR (serial_cx.connection_made:
|
||
`dtr = False`, kvůli deskám, které DTR resetuje). Solo DualSerialInterface ale
|
||
bez DTR na USB neposlouchá — odtud „No response … serial companion?“ u
|
||
meshcli na L1. Proto DTR po otevření zase nahodit."""
|
||
from meshcore import serial_cx
|
||
proto = serial_cx.SerialConnection.MCSerialClientProtocol
|
||
orig = proto.connection_made
|
||
|
||
def connection_made(self, transport):
|
||
orig(self, transport)
|
||
if getattr(transport, "serial", None):
|
||
transport.serial.dtr = True
|
||
proto.connection_made = connection_made
|
||
|
||
|
||
async def connect(port):
|
||
# a BLE MAC instead of a port: a companion that is not on USB here (the
|
||
# probe card sits on another host, reachable over BLE only)
|
||
ble = re.fullmatch(r"([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}", port) is not None
|
||
if not ble:
|
||
_dtr_on()
|
||
for attempt in range(4):
|
||
try:
|
||
if ble:
|
||
mc = await MeshCore.create_ble(port, default_timeout=8)
|
||
else:
|
||
mc = await MeshCore.create_serial(port, 115200, default_timeout=8, cx_dly=1.5)
|
||
if mc and mc.self_info:
|
||
return mc
|
||
if mc:
|
||
await mc.disconnect()
|
||
except (OSError, asyncio.TimeoutError, ConnectionError) as e:
|
||
print(f"pokus {attempt + 1}: {e}", file=sys.stderr)
|
||
await asyncio.sleep(2 + attempt * 2)
|
||
sys.exit("companion neodpovídá (připojený telefon přes BLE? po flashi chvíli počkej)")
|
||
|
||
|
||
async def cli(mc, cmd):
|
||
ev = await mc.commands.run_cli_command(cmd)
|
||
return ev.payload.get("text", "").strip() if ev.type == EventType.CLI_REPLY else None
|
||
|
||
|
||
async def cli_settings(mc):
|
||
"""Všechny klíče z `keys` (po stránkách) a jejich hodnoty z `get`; None, když
|
||
firmware Solo CLI nemá (upstream companion: „Unknown command“)."""
|
||
keys, page = [], 1
|
||
while page < 20:
|
||
r = await cli(mc, "keys" if page == 1 else f"keys {page}")
|
||
if not r or r.startswith(("Unknown", "Error", "No more")):
|
||
break
|
||
more = "(more: keys" in r
|
||
keys += r.split(" (more:")[0].split()
|
||
if not more:
|
||
break
|
||
page += 1
|
||
if not keys:
|
||
return None
|
||
out = {}
|
||
for k in keys:
|
||
r = await cli(mc, f"get {k}")
|
||
out[k] = r[2:] if r and r.startswith("> ") else r
|
||
return out
|
||
|
||
|
||
RESTORE_FIRST = ["share.to", "share.scope"] # cíl dřív než cokoli, co by vysílalo
|
||
|
||
|
||
async def restore(mc, saved, apply):
|
||
cur = await cli_settings(mc) or {}
|
||
order = [k for k in RESTORE_FIRST if k in saved] + [k for k in saved if k not in RESTORE_FIRST]
|
||
plan = []
|
||
for k in order:
|
||
v = saved[k]
|
||
if v is None or cur.get(k) == v or k not in cur:
|
||
continue
|
||
if k == "share.on" and v == "on":
|
||
plan.append((k, v, "PŘESKOČENO — zapnutí Live Share vysílá, zapni ho na zařízení"))
|
||
continue
|
||
plan.append((k, v, (await cli(mc, f"set {k} {v}")) if apply else "(--apply zapíše)"))
|
||
return plan
|
||
|
||
|
||
async def node_offset(mc):
|
||
ev = await mc.commands.get_time()
|
||
return ev.payload["time"] - int(time.time()) if ev.type == EventType.CURRENT_TIME else None
|
||
|
||
|
||
async def sync_clock(mc):
|
||
before = await node_offset(mc)
|
||
ev = await mc.commands.set_time(int(time.time()))
|
||
return {"before_s": before, "set": ev.type == EventType.OK, "after_s": await node_offset(mc)}
|
||
|
||
|
||
async def backup(port, restore_from=None, apply=False, sync=False):
|
||
mc = await connect(port)
|
||
out = {"taken_at": dt.datetime.now().astimezone().isoformat(timespec="seconds"), "port": port,
|
||
"self_info": plain(mc.self_info)}
|
||
ev = await mc.commands.send_device_query()
|
||
out["device"] = plain(ev.payload) if ev.type != EventType.ERROR else None
|
||
ev = await mc.commands.get_custom_vars()
|
||
out["custom_vars"] = plain(ev.payload) if ev.type != EventType.ERROR else None
|
||
ev = await mc.commands.get_contacts()
|
||
out["contacts"] = plain(ev.payload) if ev.type != EventType.ERROR else None
|
||
chans = []
|
||
for i in range(40):
|
||
ev = await mc.commands.get_channel(i)
|
||
if ev.type == EventType.ERROR:
|
||
break
|
||
chans.append(plain(ev.payload))
|
||
out["channels"] = chans
|
||
out["cli"] = await cli_settings(mc)
|
||
plan = await restore(mc, restore_from, apply) if restore_from else None
|
||
if plan and apply:
|
||
out["cli"] = await cli_settings(mc)
|
||
out["clock"] = await sync_clock(mc) if sync else {"before_s": await node_offset(mc)}
|
||
await mc.disconnect()
|
||
return out, plan
|
||
|
||
|
||
def summary(b):
|
||
si = b["self_info"]
|
||
used = [c for c in b["channels"] if c.get("channel_name")]
|
||
return (f"{si.get('name')} pubkey {str(si.get('public_key'))[:8]} · {si.get('radio_freq')}/{si.get('radio_bw')}/"
|
||
f"SF{si.get('radio_sf')}/CR{si.get('radio_cr')} · fw {(b.get('device') or {}).get('ver')} · "
|
||
f"{len(b.get('contacts') or {})} kontaktů · kanály: "
|
||
+ ", ".join(f"{c.get('channel_idx')}={c.get('channel_name')}" for c in used))
|
||
|
||
|
||
def diff(old, new):
|
||
keys = sorted(set(old["self_info"]) | set(new["self_info"]))
|
||
d = [f"self_info.{k}: {old['self_info'].get(k)} → {new['self_info'].get(k)}"
|
||
for k in keys if old["self_info"].get(k) != new["self_info"].get(k)]
|
||
if old.get("custom_vars") != new.get("custom_vars"):
|
||
d.append(f"custom_vars: {old.get('custom_vars')} → {new.get('custom_vars')}")
|
||
oc = {c["channel_idx"]: c for c in old["channels"]}
|
||
for c in new["channels"]:
|
||
o = oc.get(c["channel_idx"], {})
|
||
if o.get("channel_name") != c.get("channel_name") or o.get("channel_secret") != c.get("channel_secret"):
|
||
d.append(f"kanál {c['channel_idx']}: {o.get('channel_name')} → {c.get('channel_name')}"
|
||
+ (" (jiný klíč)" if o.get("channel_secret") != c.get("channel_secret") else ""))
|
||
oc, nc = old.get("cli") or {}, new.get("cli") or {}
|
||
for k in sorted(set(oc) | set(nc)):
|
||
if oc.get(k) != nc.get(k):
|
||
d.append(f"cli {k}: {oc.get(k)} → {nc.get(k)}")
|
||
ok, nk = set(old.get("contacts") or {}), set(new.get("contacts") or {})
|
||
if ok != nk:
|
||
d.append(f"kontakty: −{len(ok - nk)} +{len(nk - ok)}")
|
||
return d
|
||
|
||
|
||
def main():
|
||
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||
ap.add_argument("port", help="/dev/serial/by-id/... nebo BLE MAC")
|
||
ap.add_argument("name", help="jméno zálohy, např. L1-pre-flash")
|
||
ap.add_argument("--diff", metavar="JSON", help="porovnat se starší zálohou")
|
||
ap.add_argument("--restore", metavar="JSON", help="vrátit nastavení z CLI sekce zálohy (bez --apply jen ukáže)")
|
||
ap.add_argument("--apply", action="store_true", help="s --restore opravdu zapsat")
|
||
ap.add_argument("--sync-time", action="store_true", help="nastavit čas hostu (s --diff automaticky)")
|
||
a = ap.parse_args()
|
||
saved = None
|
||
if a.restore:
|
||
with open(os.path.expanduser(a.restore)) as f:
|
||
saved = json.load(f).get("cli")
|
||
if not saved:
|
||
sys.exit(f"{a.restore}: záloha nemá sekci cli (starší skript nebo firmware bez Solo CLI)")
|
||
b, plan = asyncio.run(backup(a.port, saved, a.apply, a.sync_time or bool(a.diff)))
|
||
os.makedirs(DIR, mode=0o700, exist_ok=True)
|
||
path = os.path.join(DIR, f"{a.name}-{dt.datetime.now().astimezone().date()}.json")
|
||
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
|
||
with os.fdopen(fd, "w") as f:
|
||
json.dump(b, f, ensure_ascii=False, indent=1)
|
||
print(f"záloha: {path}\n{summary(b)}")
|
||
if b["cli"] is not None:
|
||
sh = {k: v for k, v in b["cli"].items() if k.startswith("share.")}
|
||
print(f"CLI: {len(b['cli'])} klíčů; Live Share: " + ", ".join(f"{k}={v}" for k, v in sh.items()))
|
||
else:
|
||
print("CLI: firmware Solo CLI nemá — Solo prefs zkontroluj na zařízení")
|
||
c = b["clock"]
|
||
if "set" not in c:
|
||
print(f"hodiny: odchylka {c['before_s']:+} s" if c["before_s"] is not None else "hodiny: nepřečteny")
|
||
elif c["set"]:
|
||
print(f"hodiny: odchylka {c['before_s']:+} s → srovnáno ({c['after_s']:+} s)")
|
||
else:
|
||
print(f"hodiny: odchylka {c['before_s']:+} s → firmware nastavení odmítl (čas dozadu?)")
|
||
if plan is not None:
|
||
print("\nobnova z " + a.restore + ":\n" + ("\n".join(f"- set {k} {v} → {r}" for k, v, r in plan)
|
||
if plan else "- nic, vše sedí"))
|
||
if a.diff:
|
||
with open(os.path.expanduser(a.diff)) as f:
|
||
d = diff(json.load(f), b)
|
||
print("\nrozdíly proti " + a.diff + ":\n" + ("\n".join("- " + x for x in d) if d else "- žádné"))
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|