Files
meshcore-tth/tools/companion_backup.py
T

261 lines
11 KiB
Python
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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()