os: Add online update support (#958)

I originally wanted to use [Rauc
poller](https://rauc.readthedocs.io/en/latest/reference.html#poller-interface)
but unfortunately that feature is not available in Rauc stable (1.5.2 as
of writing) yet.

See https://rauc.readthedocs.io/en/latest/advanced.html#update-polling

So instead I implemented a similar and simpler poll mechanism. There is
no automatic poll, user needs to check for updates.

See `backend/src/update.md` for API.

Author: sonnyp

backend/src/service.js

@@ -29,8 +29,6 @@ app.post("/api/capture", async (req, res) => {
   res.json({ url_jpeg: url })
 })
 
-app.use("/api/files", express.static("/home/pi/data"))
-
 app.post("/api/reset", async (req, res) => {
   await removeConfig()
   res.status(200)

backend/src/update.js

@@ -12,9 +12,13 @@ import { reboot } from "../../lib/hardware.js"
 
 import app from "./app.js"
 import { watchProperty } from "../../lib/dbus-helpers.js"
-
-const service = systemBus().getService("de.pengutronix.rauc")
-const rauc = await service.getInterface("/", "de.pengutronix.rauc.Installer")
+import {
+  installer,
+  getBundleInfo,
+  triggerInstall,
+  checkForUpdate,
+} from "../../lib/software.js"
+import { procedure, publish } from "../../lib/mqtt.js"
 
 const uploads = multer({
   dest: "/data/tmp",
@@ -25,29 +29,6 @@ app.post("/api/update/upload", uploads.single("bundle"), async (req, res) => {
   res.json(info)
 })
 
-app.post("/api/update/install", express.json(), async (req, res) => {
-  const { path } = req.body
-  if (!path) {
-    res.status(404)
-    res.end()
-    return
-  }
-
-  await triggerInstall(path)
-
-  res.status(200)
-  res.end()
-})
-
-app.post("/api/update/reboot", async (req, res) => {
-  res.status(201)
-  res.end()
-
-  setTimeout(() => {
-    reboot().catch(console.error)
-  }, 1000)
-})
-
 const props = [
   "Operation",
   "LastError",
@@ -58,80 +39,62 @@ const signals = ["Completed"]
 
 async function getStatus() {
   const values = await Promise.all(
-    props.map((prop) => readProperty(rauc, prop)),
+    props.map((prop) => readProperty(installer, prop)),
   )
   const obj = Object.fromEntries(props.map((key, i) => [key, values[i]]))
   return obj
 }
 
-// Keep track of clients
-const clients = new Set()
-app.get("/api/update/events", (req, res) => {
-  // Required SSE headers
-  res.setHeader("Content-Type", "text/event-stream")
-  res.setHeader("Cache-Control", "no-cache")
-  res.setHeader("Connection", "keep-alive")
-
-  // Send initial comment to establish connection in some proxies
-  res.flushHeaders?.()
-
-  const client = {
-    id: Date.now(),
-    res,
-  }
-  clients.add(client)
-
-  getStatus()
-    .then((data) => {
-      client.res.write(`data: ${JSON.stringify(data)}\n\n`)
-    })
-    .catch(console.error)
-
-  req.on("close", () => {
-    clients.delete(client)
-  })
-})
-
-function broadcast(data) {
-  clients.forEach((client) => {
-    client.res.write(`data: ${JSON.stringify(data)}\n\n`)
+async function publishStatus() {
+  const status = await getStatus()
+  await publish("software-updater/status", status, null, {
+    retain: true,
   })
 }
 
 props.forEach((prop) => {
-  watchProperty(rauc, prop).subscribe(async () => {
-    const status = await getStatus()
-    broadcast(status)
-  })
+  watchProperty(installer, prop).subscribe(() => publishStatus())
 })
 
-// https://rauc.readthedocs.io/en/latest/reference.html#installbundle-method
-async function triggerInstall(path) {
-  await rauc.InstallBundle(path, [])
-  const current_operation = await readProperty(rauc, "Operation")
-  if (current_operation !== "installing")
-    throw new Error(`Current rauc operation is "${current_operation}".`)
-}
+await publishStatus()
+
+await procedure("software-updater", async (data) => {
+  if (data.action == "poll") {
+    await poll()
+    return
+  }
 
-// https://rauc.readthedocs.io/en/latest/reference.html#inspectbundle-method
-async function getBundleInfo(path) {
-  const raw = await rauc.InspectBundle(path, [])
-  const normalized = normalizeDbus(raw)
-  const dictEntries = normalized[0]
-  const result = Object.fromEntries(dictEntries)
+  if (data.action == "install") {
+    await triggerInstall(data.uri)
+    return
+  }
 
-  const { version, compatible, build } = result.update
+  if (data.action == "info") {
+    return getBundleInfo(data.uri)
+  }
 
-  return {
-    version,
-    build,
-    compatible,
-    path,
+  if (data.action == "reboot") {
+    setTimeout(() => {
+      reboot().catch(console.error)
+    }, 1000)
+    return
   }
+})
+
+async function poll() {
+  const bundle_info = await checkForUpdate()
+  await publish(
+    "software-updater/update-available",
+    [!!bundle_info, bundle_info],
+    null,
+    {
+      retain: true,
+    },
+  )
 }
 
 if (import.meta.main) {
   console.log(await getStatus())
-  // await triggerInstall("/data/tmp/fpp")
-  // await getBundleInfo("/data/tmp/e5464c1b6a138ca358e9683cbe5d73f8")
+  const bundle_info = await getBundleInfo(url)
+  console.log(bundle_info)
 }

backend/src/update.md

@@ -0,0 +1,106 @@
+# software-updater service
+
+backend automatically starts this software-updater service
+
+### API
+
+### Poll for an update:
+
+**topic** `software-updater`
+
+**payload:**
+```json
+{
+  "action": "poll",
+}
+```
+
+It will instruct the service to check for a new update.
+
+See status below for watching availability of update.
+
+### Info about an update:
+
+**topic** `software-updater`
+
+**payload:**
+```json
+{
+  "action": "info",
+  "uri": "..."
+}
+```
+
+`uri` can be a http(s) URL or a path on disk.
+It will respond with something like:
+
+```json
+{
+  "version": "some-version-string",
+  "build": "some-unique-build-id-string",
+  "compatible": "PlanktoScope,rev1",
+  "uri": "the uri passed to the payload"
+}
+```
+
+### Install an update:
+
+**topic** `software-updater`
+
+**payload:**
+```json
+{
+  "action": "install",
+  "uri": "..."
+}
+```
+
+`uri` can be a http(s) URL or a path on disk.
+
+See status below for watching progress of install.
+
+### Reboot:
+
+**topic** `software-updater`
+
+**payload:**
+```json
+{
+  "action": "reboot"
+}
+```
+
+Reboots the PlanktoScope.
+This is necessary after an update installation completes.
+
+### status
+
+**topic** `software-updater/status`
+
+**payload:**
+```json
+{
+  "Operation": "", // https://rauc.readthedocs.io/en/v1.15.2/reference.html#operation-property
+  "LastError": "", // https://rauc.readthedocs.io/en/v1.15.2/reference.html#lasterror-property
+  "Progress": "" // https://rauc.readthedocs.io/en/v1.15.2/reference.html#progress-property
+}
+```
+
+**topic** `software-updater/update-available`
+
+**payload when no update available:**
+
+```json
+[false, null]
+```
+
+**payload when update available:**
+
+```json
+[true, {
+  "version": "some-version-string",
+  "build": "some-unique-build-id-string",
+  "compatible": "PlanktoScope,rev1",
+  "uri": "the uri passed to the payload"
+}]
+```

frontend/package-lock.json

@@ -13,7 +13,6 @@
     "@solidjs/router": "^0.15.4",
     "array-shuffle": "^4.0.0",
     "autoprefixer": "^10.4.22",
-    "eventsource-client": "^1.2.0",
     "medium-zoom": "^1.1.0",
     "mqtt": "^5.14.1",
     "observable-polyfill": "^0.0.29",