266 lines
12 KiB
Bash
Executable File
266 lines
12 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# fleet_install.sh — deploy/manage a Sanad fleet agent on a robot over SSH,
|
|
# as FULL DOCKER with a user-level systemd auto-start service.
|
|
#
|
|
# INTERACTIVE (no args): ./fleet_install.sh
|
|
# → pick robot type → enter IP → it detects whether the agent is already
|
|
# installed and offers the right actions (install / uninstall / data / ...).
|
|
#
|
|
# SCRIPTABLE:
|
|
# ./fleet_install.sh install <g1|r1|go2> <ip> [--sn NAME] [--server-ip IP] [--port N] [--token TOK] [--user U]
|
|
# ./fleet_install.sh uninstall <g1|r1|go2> <ip> [--user U]
|
|
# ./fleet_install.sh status <g1|r1|go2> <ip>
|
|
# ./fleet_install.sh data <g1|r1|go2> <ip> # show the data it is sending
|
|
# ./fleet_install.sh logs <g1|r1|go2> <ip>
|
|
# ./fleet_install.sh test <g1|r1|go2> <ip> [--server-ip IP] [--keep-server]
|
|
#
|
|
# Deploy model: rsync the canonical workstation copy -> robot, `docker build`
|
|
# on the robot (native arm64), `docker create` the container, and a user
|
|
# systemd unit (linger-enabled) owns start/stop/auto-start. No docker-compose
|
|
# needed on the robot; no sudo needed (user-level systemd).
|
|
set -uo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
|
AGENTS="$SCRIPT_DIR/agents"
|
|
TYPES="g1 r1 go2"
|
|
declare -A KIND=( [g1]="MAP uploader" [r1]="TELEMETRY (unitree_hg)" [go2]="TELEMETRY (unitree_go)" )
|
|
|
|
die(){ echo "ERROR: $*" >&2; exit 1; }
|
|
img_of(){ echo "sanad-api-$1"; } # image + container + unit share this base
|
|
rdir_of(){ echo "sanad_api_$1"; }
|
|
unit_of(){ echo "sanad-api-$1.service"; }
|
|
|
|
SSH_OPTS=(-o BatchMode=yes -o ConnectTimeout=8 -o StrictHostKeyChecking=accept-new)
|
|
rmt(){ ssh -n "${SSH_OPTS[@]}" "$USER_@$IP" "$@"; } # -n: never read our stdin
|
|
rmt_in(){ ssh "${SSH_OPTS[@]}" "$USER_@$IP" "$@"; } # stdin passthrough (heredocs)
|
|
detect_server_ip(){ [ -n "$SERVER_IP" ] && { echo "$SERVER_IP"; return; }
|
|
ip -o route get "$IP" 2>/dev/null | grep -oP 'src \K\S+' | head -1; }
|
|
|
|
# ---- per-type docker create args (volumes differ) ----
|
|
run_args(){
|
|
local base="--network host --env-file /home/$USER_/$(rdir_of "$1")/.env"
|
|
if [ "$1" = g1 ]; then
|
|
echo "$base -v /home/$USER_/$(rdir_of "$1")/maps:/data/maps:ro \
|
|
-v /home/$USER_/$(rdir_of "$1")/web_data:/data/web_data:ro \
|
|
-v /home/$USER_/$(rdir_of "$1")/state:/data/state"
|
|
else
|
|
echo "$base"
|
|
fi
|
|
}
|
|
|
|
# ---- write the robot-side .env ----
|
|
push_env(){
|
|
local t="$1" sip="$2" rdir; rdir="$(rdir_of "$t")"
|
|
if [ "$t" = g1 ]; then
|
|
rmt_in "cat > ~/$rdir/.env" <<EOF
|
|
SERVER_URL=http://$sip:$PORT
|
|
DEVICE_TOKEN=$TOKEN
|
|
SN=$SN
|
|
ROBOT=sanad
|
|
MAPS_DIR=/data/maps
|
|
DATA_DIR=/data/web_data
|
|
STATE_DIR=/data/state
|
|
MAP_UPLOAD_MODE=multipart
|
|
VERIFY_TLS=0
|
|
POLL_INTERVAL=30
|
|
EOF
|
|
else
|
|
local iface=eth0; [ "$t" = r1 ] && iface=eth10
|
|
rmt_in "cat > ~/$rdir/.env" <<EOF
|
|
SERVER_URL=http://$sip:$PORT
|
|
DEVICE_TOKEN=$TOKEN
|
|
SN=$SN
|
|
DDS_INTERFACE=$iface
|
|
DDS_DOMAIN=0
|
|
VERIFY_TLS=0
|
|
POLL_INTERVAL=2
|
|
EOF
|
|
fi
|
|
}
|
|
|
|
installed(){ # 0 = installed (unit file OR container present)
|
|
rmt "test -f ~/.config/systemd/user/$(unit_of "$1") || docker container inspect $(img_of "$1") >/dev/null 2>&1" 2>/dev/null
|
|
}
|
|
|
|
do_install(){
|
|
local t="$1" img rdir unit sip; img="$(img_of "$t")"; rdir="$(rdir_of "$t")"; unit="$(unit_of "$t")"
|
|
sip="$(detect_server_ip)"; [ -n "$sip" ] || die "cannot detect server IP toward $IP (use --server-ip)"
|
|
echo "== INSTALL $t ($SN) on $IP → fleet server http://$sip:$PORT =="
|
|
echo ">> rsync agent -> $USER_@$IP:~/$rdir/"
|
|
rsync -az --delete --exclude '.env' --exclude '__pycache__' --exclude '*.pyc' \
|
|
--exclude 'data/' --exclude 'state/' \
|
|
-e "ssh ${SSH_OPTS[*]}" "$AGENTS/$t/" "$USER_@$IP:~/$rdir/" || die "rsync failed"
|
|
rmt "mkdir -p ~/$rdir/maps/sanad ~/$rdir/web_data ~/$rdir/state ~/.config/systemd/user"
|
|
push_env "$t" "$sip"
|
|
echo ">> docker build on robot (native arm64; R1/Go2 compile DDS on first build) ..."
|
|
rmt "cd ~/$rdir && docker build -t $img:latest ." || die "docker build failed"
|
|
echo ">> creating container (systemd will own its lifecycle) ..."
|
|
rmt "docker rm -f $img >/dev/null 2>&1; docker create --name $img $(run_args "$t") $img:latest >/dev/null"
|
|
echo ">> installing user systemd service $unit (auto-start on boot via linger) ..."
|
|
rmt_in "cat > ~/.config/systemd/user/$unit" <<EOF
|
|
[Unit]
|
|
Description=Sanad Fleet Agent ($t) -> $SN
|
|
After=docker.service network-online.target
|
|
|
|
[Service]
|
|
Type=simple
|
|
Restart=always
|
|
RestartSec=5
|
|
ExecStart=/usr/bin/docker start -a $img
|
|
ExecStop=/usr/bin/docker stop -t 10 $img
|
|
|
|
[Install]
|
|
WantedBy=default.target
|
|
EOF
|
|
rmt "loginctl enable-linger \$USER >/dev/null 2>&1; \
|
|
systemctl --user daemon-reload; \
|
|
systemctl --user enable --now $unit"
|
|
sleep 2
|
|
echo ">> service state:"; rmt "systemctl --user --no-pager -l status $unit | sed -n '1,4p'"
|
|
echo "== installed. show data: $0 data $t $IP =="
|
|
}
|
|
|
|
do_uninstall(){
|
|
local t="$1" img unit rdir; img="$(img_of "$t")"; unit="$(unit_of "$t")"; rdir="$(rdir_of "$t")"
|
|
echo "== UNINSTALL $t on $IP =="
|
|
rmt "systemctl --user disable --now $unit >/dev/null 2>&1; \
|
|
rm -f ~/.config/systemd/user/$unit; systemctl --user daemon-reload; \
|
|
docker rm -f $img >/dev/null 2>&1; docker rmi $img:latest >/dev/null 2>&1; \
|
|
rm -rf ~/$rdir; echo ' removed service, container, image, and ~/'$rdir"
|
|
echo "== uninstalled =="
|
|
}
|
|
|
|
do_status(){
|
|
local t="$1" img unit; img="$(img_of "$t")"; unit="$(unit_of "$t")"
|
|
echo "== STATUS $t on $IP =="
|
|
rmt "systemctl --user --no-pager status $unit 2>/dev/null | sed -n '1,4p' || echo 'no service'; echo; \
|
|
docker ps -a --filter name=$img --format 'container: {{.Names}} {{.Status}} ({{.Image}})' || echo 'no container'"
|
|
}
|
|
|
|
do_logs(){ rmt "docker logs --tail 40 -f $(img_of "$1")"; }
|
|
|
|
do_data(){
|
|
local t="$1" img; img="$(img_of "$t")"
|
|
echo "== DATA $t on $IP (what it is sending to the fleet server) =="
|
|
rmt "systemctl --user --no-pager status $(unit_of "$t") 2>/dev/null | sed -n '1,3p'; echo '--- recent telemetry/map posts ---'; \
|
|
docker logs --tail 12 $img 2>&1 | grep -E 'telemetry ok|uploaded|nothing to upload|heartbeat|POST failed' | tail -8 || docker logs --tail 12 $img 2>&1"
|
|
}
|
|
|
|
# ---- deploy-less end-to-end test against the workstation server ----
|
|
start_server(){ local reqlog="/tmp/fleet_reqs_${1}_$$.jsonl"; echo "$reqlog" > /tmp/fleet_last_reqlog
|
|
PORT=$PORT REQLOG="$reqlog" python3 "$SCRIPT_DIR/fleet_test_server.py" >/tmp/fleet_srv_$$.log 2>&1 &
|
|
echo $! > /tmp/fleet_srv_pid; sleep 1; }
|
|
stop_server(){ [ -f /tmp/fleet_srv_pid ] && kill "$(cat /tmp/fleet_srv_pid)" 2>/dev/null; rm -f /tmp/fleet_srv_pid; }
|
|
|
|
do_test(){
|
|
local t="$1" img sip; img="$(img_of "$t")"
|
|
sip="$(detect_server_ip)"; [ -n "$sip" ] || die "cannot detect server IP (use --server-ip)"
|
|
echo "== TEST $t via $IP (workstation server http://$sip:$PORT) =="
|
|
rmt "docker image inspect $img:latest >/dev/null 2>&1" || { echo ">> not installed yet — installing first"; do_install "$t"; }
|
|
push_env "$t" "$sip"
|
|
start_server "$t"; trap 'stop_server' EXIT
|
|
local rc; rc=$(rmt "curl -s -o /dev/null -w '%{http_code}' --max-time 6 http://$sip:$PORT/ping" || echo 000)
|
|
[ "$rc" = 200 ] || die "robot cannot reach workstation server (http $rc) — firewall on $sip:$PORT?"
|
|
echo " reachability OK (HTTP $rc)"
|
|
if [ "$t" = g1 ]; then
|
|
rmt "mkdir -p ~/$(rdir_of g1)/maps/sanad ~/$(rdir_of g1)/web_data/sanad/places
|
|
head -c 4096 /dev/urandom > ~/$(rdir_of g1)/maps/sanad/floor-test.db
|
|
printf '%s' '{\"dock\":{\"x\":1.2,\"y\":3.4,\"qz\":0,\"qw\":1}}' > ~/$(rdir_of g1)/web_data/sanad/places/floor-test.json
|
|
rm -f ~/$(rdir_of g1)/state/uploaded.json"
|
|
rmt "docker run --rm $(run_args g1) $img:latest --once --force" || true
|
|
else
|
|
echo ">> real DDS --once:"; rmt "docker run --rm $(run_args "$t") $img:latest --once" || true
|
|
echo ">> simulate --once:"; rmt "docker run --rm $(run_args "$t") $img:latest --simulate --once" || true
|
|
fi
|
|
sleep 1; echo; echo ">> workstation server received:"
|
|
local reqlog; reqlog="$(cat /tmp/fleet_last_reqlog)"; local result=0
|
|
python3 - "$reqlog" "$t" <<'PY' && result=0 || result=$?
|
|
import json,sys,os
|
|
recs=[json.loads(l) for l in open(sys.argv[1])] if os.path.exists(sys.argv[1]) else []
|
|
t=sys.argv[2]
|
|
for r in recs:
|
|
j=r.get("json")
|
|
print(" POST",r["path"],"auth="+("yes" if r["auth"].startswith("Bearer") else "NO"))
|
|
if j: print(" ",{k:j[k] for k in j if k!="db_base64"})
|
|
if r.get("meta"): print(" meta:",r["meta"][:160])
|
|
ok=any(x["path"].endswith("/map") and x["ctype"]=="multipart/form-data" for x in recs) if t=="g1" \
|
|
else any(x["path"].endswith("/telemetry") for x in recs)
|
|
print(f"\n RESULT: {'PASS' if ok else 'FAIL'} ({len(recs)} request(s))")
|
|
sys.exit(0 if ok else 1)
|
|
PY
|
|
[ "${KEEP_SERVER:-0}" = 1 ] && { echo ">> --keep-server: server still up (pid $(cat /tmp/fleet_srv_pid 2>/dev/null))"; trap - EXIT; }
|
|
return $result
|
|
}
|
|
|
|
# --------------------------- arg parsing --------------------------- #
|
|
CMD=""; ROBOT=""; IP=""; SERVER_IP=""; PORT=8799; TOKEN="test-token"; SN=""; USER_="unitree"; KEEP_SERVER=0
|
|
POSA=()
|
|
while [ $# -gt 0 ]; do case "$1" in
|
|
--server-ip) SERVER_IP="$2"; shift 2;;
|
|
--port) PORT="$2"; shift 2;;
|
|
--token) TOKEN="$2"; shift 2;;
|
|
--sn) SN="$2"; shift 2;;
|
|
--user) USER_="$2"; shift 2;;
|
|
--keep-server) KEEP_SERVER=1; shift;;
|
|
-h|--help) grep -E '^#( |$)' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
|
|
*) POSA+=("$1"); shift;;
|
|
esac; done
|
|
CMD="${POSA[0]:-}"; ROBOT="${POSA[1]:-}"; IP="${POSA[2]:-}"
|
|
|
|
# --------------------------- interactive --------------------------- #
|
|
choose_type(){
|
|
echo "Which robot?" >&2; local i=1
|
|
for t in $TYPES; do echo " $i) $t — ${KIND[$t]}" >&2; i=$((i+1)); done
|
|
read -rp "Choice [1-3]: " c
|
|
case "$c" in 1) echo g1;; 2) echo r1;; 3) echo go2;; g1|r1|go2) echo "$c";; *) echo "";; esac
|
|
}
|
|
|
|
interactive(){
|
|
echo "=== Sanad Fleet Agent Installer ==="
|
|
ROBOT="$(choose_type)"; [ -n "$ROBOT" ] || die "invalid robot type"
|
|
read -rp "Robot IP: " IP; [ -n "$IP" ] || die "no IP"
|
|
read -rp "SSH user [$USER_]: " u; [ -n "$u" ] && USER_="$u"
|
|
rmt true 2>/dev/null || die "cannot SSH to $USER_@$IP (key auth?)"
|
|
if installed "$ROBOT"; then
|
|
echo; echo ">> '$(img_of "$ROBOT")' is ALREADY INSTALLED on $IP."
|
|
echo " 1) show data 2) status 3) logs 4) reinstall 5) UNINSTALL 6) quit"
|
|
read -rp "Choice: " a
|
|
case "$a" in
|
|
1) do_data "$ROBOT";; 2) do_status "$ROBOT";; 3) do_logs "$ROBOT";;
|
|
4) prompt_install; do_install "$ROBOT";;
|
|
5) read -rp "Really uninstall $(img_of "$ROBOT") from $IP? [y/N] " y; [ "$y" = y ] && do_uninstall "$ROBOT" || echo "cancelled";;
|
|
*) echo "bye";;
|
|
esac
|
|
else
|
|
echo; echo ">> not installed yet — let's install."
|
|
prompt_install
|
|
do_install "$ROBOT"
|
|
fi
|
|
}
|
|
|
|
prompt_install(){
|
|
local def="${ROBOT}_${IP##*.}"
|
|
read -rp "Robot name / SN [$def]: " s; SN="${s:-$def}"
|
|
local autos; autos="$(detect_server_ip)"
|
|
read -rp "Fleet server IP [${autos:-required}]: " si; [ -n "$si" ] && SERVER_IP="$si" || SERVER_IP="${SERVER_IP:-$autos}"
|
|
read -rp "Server port [$PORT]: " p; [ -n "$p" ] && PORT="$p"
|
|
read -rp "Device token [$TOKEN]: " tk; [ -n "$tk" ] && TOKEN="$tk"
|
|
}
|
|
|
|
# --------------------------- dispatch --------------------------- #
|
|
[ -z "$CMD" ] && { interactive; exit $?; }
|
|
[ -n "$ROBOT" ] && [ -n "$IP" ] || die "usage: $0 <install|uninstall|status|data|logs|test> <g1|r1|go2> <ip> [opts] (or run with no args for interactive)"
|
|
echo "$TYPES" | grep -qw "$ROBOT" || die "robot must be one of: $TYPES"
|
|
[ -d "$AGENTS/$ROBOT" ] || die "agent dir missing: $AGENTS/$ROBOT"
|
|
[ -z "$SN" ] && SN="${ROBOT}_${IP##*.}"
|
|
|
|
case "$CMD" in
|
|
install) do_install "$ROBOT";;
|
|
uninstall) do_uninstall "$ROBOT";;
|
|
status) do_status "$ROBOT";;
|
|
data) do_data "$ROBOT";;
|
|
logs) do_logs "$ROBOT";;
|
|
test) do_test "$ROBOT";;
|
|
*) die "unknown command: $CMD (install|uninstall|status|data|logs|test)";;
|
|
esac
|