Captive portal wifi setup (#135)

Author: mariusandra

backend/app/api/frames.py

@@ -489,7 +489,7 @@ async def api_frame_clear_build_cache(id: int, redis: Redis = Depends(get_redis)
     try:
         ssh = await get_ssh_connection(db, redis, frame)
         try:
-            command = "rm -rf /srv/frameos/build/cache"
+            command = "rm -rf /srv/frameos/build/cache && echo 'Build cache cleared'"
             await exec_command(db, redis, frame, ssh, command)
         finally:
             await remove_ssh_connection(db, redis, ssh, frame)
@@ -516,6 +516,15 @@ async def api_frame_restart_event(id: int, redis: Redis = Depends(get_redis)):
     except Exception as e:
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
 
+@api_with_auth.post("/frames/{id:int}/reboot")
+async def api_frame_reboot_event(id: int, redis: Redis = Depends(get_redis)):
+    try:
+        from app.tasks import reboot_frame
+        await reboot_frame(id, redis)
+        return "Success"
+    except Exception as e:
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
+
 
 @api_with_auth.post("/frames/{id:int}/stop")
 async def api_frame_stop_event(id: int, redis: Redis = Depends(get_redis)):
@@ -574,6 +583,9 @@ async def api_frame_update_endpoint(
     if data.next_action == 'restart':
         from app.tasks import restart_frame
         await restart_frame(id, redis)
+    elif data.next_action == 'reboot':
+        from app.tasks import reboot_frame
+        await reboot_frame(id, redis)
     elif data.next_action == 'stop':
         from app.tasks import stop_frame
         await stop_frame(id, redis)

backend/app/models/frame.py

@@ -150,7 +150,15 @@ async def new_frame(db: Session, redis: Redis, name: str, frame_host: str, serve
         assets_path='/srv/assets',
         save_assets=True,
         upload_fonts='', # all
-        network={"networkCheck": True, "networkCheckTimeoutSeconds": 60, "networkCheckUrl": "https://networkcheck.frameos.net/"},
+        network={
+            "networkCheck": True,
+            "networkCheckTimeoutSeconds": 30,
+            "networkCheckUrl": "https://networkcheck.frameos.net/",
+            "wifiHotspot": "disabled",
+            "wifiHotspotSsid": "FrameOS-Setup",
+            "wifiHotspotPassword": "frame1234",
+            "wifiHotspotTimeoutSeconds": 600,
+        },
         control_code={"enabled": "true", "position": "top-right"},
         schedule={"events": []},
         reboot={"enabled": "true", "crontab": "4 0 * * *"},
@@ -239,8 +247,12 @@ def get_frame_json(db: Session, frame: Frame) -> dict:
         } if frame.control_code else {"enabled": False},
         "network": {
             "networkCheck": network.get('networkCheck', True),
-            "networkCheckTimeoutSeconds": int(network.get('networkCheckTimeoutSeconds', 60)),
+            "networkCheckTimeoutSeconds": int(network.get('networkCheckTimeoutSeconds', 30)),
             "networkCheckUrl": network.get('networkCheckUrl', "https://networkcheck.frameos.net/"),
+            "wifiHotspot": network.get('wifiHotspot', "disabled"),
+            "wifiHotspotSsid": network.get('wifiHotspotSsid', "FrameOS-Setup"),
+            "wifiHotspotPassword": network.get('wifiHotspotPassword', "frame1234"),
+            "wifiHotspotTimeoutSeconds": int(network.get('wifiHotspotTimeoutSeconds', 600)),
         }
     }
 

backend/app/tasks/__init__.py

@@ -1,5 +1,5 @@
 from .fast_deploy_frame import fast_deploy_frame # noqa
 from .deploy_frame import deploy_frame # noqa
 from .reset_frame import reset_frame # noqa
-from .restart_frame import restart_frame # noqa
+from .restart_frame import restart_frame, reboot_frame # noqa
 from .stop_frame import stop_frame # noqa

backend/app/tasks/deploy_frame.py

@@ -128,6 +128,7 @@ async def install_if_necessary(pkg: str, raise_on_error=True) -> int:
             # 2. Remote steps
             await install_if_necessary("ntp")
             await install_if_necessary("build-essential")
+            await install_if_necessary("hostapd")
 
             if drivers.get("evdev"):
                 await install_if_necessary("libevdev-dev")

backend/app/tasks/restart_frame.py

@@ -41,3 +41,32 @@ async def restart_frame_task(ctx: dict[str, Any], id: int):
     finally:
         if ssh is not None:
             await remove_ssh_connection(db, redis, ssh, frame)
+
+async def reboot_frame(id: int, redis: Redis):
+    await redis.enqueue_job("reboot_frame", id=id)
+
+async def reboot_frame_task(ctx: dict[str, Any], id: int):
+    db: Session = ctx['db']
+    redis: Redis = ctx['redis']
+
+    ssh = None
+    frame = None
+    try:
+        frame = db.get(Frame, id)
+        if not frame:
+            await log(db, redis, id, "stderr", "Frame not found")
+            return
+
+        frame.status = 'rebooting'
+        await update_frame(db, redis, frame)
+        ssh = await get_ssh_connection(db, redis, frame)
+        await exec_command(db, redis, frame, ssh, "sudo reboot")
+
+    except Exception as e:
+        await log(db, redis, id, "stderr", str(e))
+        if frame:
+            frame.status = 'uninitialized'
+            await update_frame(db, redis, frame)
+    finally:
+        if ssh is not None:
+            await remove_ssh_connection(db, redis, ssh, frame)

backend/app/tasks/worker.py

@@ -12,7 +12,7 @@
 from app.tasks.deploy_frame import deploy_frame_task
 from app.tasks.fast_deploy_frame import fast_deploy_frame_task
 from app.tasks.reset_frame import reset_frame_task
-from app.tasks.restart_frame import restart_frame_task
+from app.tasks.restart_frame import restart_frame_task, reboot_frame_task
 from app.tasks.stop_frame import stop_frame_task
 from app.config import config
 from app.redis import create_redis_connection
@@ -49,6 +49,7 @@ class WorkerSettings:
         func(fast_deploy_frame_task, name="fast_deploy_frame"),
         func(reset_frame_task,       name="reset_frame"),
         func(restart_frame_task,     name="restart_frame"),
+        func(reboot_frame_task,      name="reboot_frame"),
         func(stop_frame_task,        name="stop_frame"),
     ]
     on_startup = startup

frameos/frame.json

@@ -69,7 +69,11 @@
     },
     "network": {
         "networkCheck": true,
-        "networkCheckSeconds": 60,
-        "networkCheckUrl": "https://networkcheck.frameos.net/"
+        "networkCheckTimeoutSeconds": 30,
+        "networkCheckUrl": "https://networkcheck.frameos.net/",
+        "wifiHotspot": "disabled",
+        "wifiHotspotSsid": "FrameOS",
+        "wifiHotspotPassword": "frame1234",
+        "wifiHotspotTimeoutSeconds": 600
     }
 }

frameos/src/frameos/channels.nim

@@ -9,7 +9,7 @@ var eventChannel*: Channel[(Option[SceneId], string, JsonNode)]
 eventChannel.open()
 
 # Send an event to the current scene
-proc sendEvent*(event: string, payload: JsonNode) =
+proc sendEvent*(event: string, payload: JsonNode) {.gcsafe.} =
   eventChannel.send((none(SceneId), event, payload))
 
 # Send an event to a specific scene

frameos/src/frameos/config.nim

@@ -61,8 +61,12 @@ proc loadNetwork*(data: JsonNode): NetworkConfig =
   else:
     result = NetworkConfig(
       networkCheck: data{"networkCheck"}.getBool(),
-      networkCheckTimeoutSeconds: data{"networkCheckTimeoutSeconds"}.getFloat(60),
+      networkCheckTimeoutSeconds: data{"networkCheckTimeoutSeconds"}.getFloat(30),
       networkCheckUrl: data{"networkCheckUrl"}.getStr("https://networkcheck.frameos.net"),
+      wifiHotspot: if data{"networkCheck"}.getBool(): data{"wifiHotspot"}.getStr("disabled") else: "disabled",
+      wifiHotspotSsid: data{"wifiHotspotSsid"}.getStr("FrameOS-Setup"),
+      wifiHotspotPassword: data{"wifiHotspotPassword"}.getStr("frame1234"),
+      wifiHostpotTimeoutSeconds: data{"wifiHotspotTimeoutSeconds"}.getFloat(600),
     )
 
 proc loadConfig*(filename: string = "frame.json"): FrameConfig =

frameos/src/frameos/frameos.nim

@@ -1,5 +1,4 @@
-import json, asyncdispatch, pixie, strutils, times, os
-import httpclient
+import json, asyncdispatch, pixie, strutils, times, os, httpclient, options
 import drivers/drivers as drivers
 import frameos/config
 import frameos/logger
@@ -8,6 +7,7 @@ import frameos/runner
 import frameos/server
 import frameos/scheduler
 import frameos/types
+import frameos/portal as netportal
 import lib/tz
 
 proc newFrameOS*(): FrameOS =
@@ -19,7 +19,11 @@ proc newFrameOS*(): FrameOS =
   result = FrameOS(
     frameConfig: frameConfig,
     logger: logger,
-    metricsLogger: metricsLogger
+    metricsLogger: metricsLogger,
+    network: Network(
+      status: NetworkStatus.idle,
+      hotspotStatus: HotspotStatus.disabled,
+    ),
   )
   drivers.init(result)
   result.runner = newRunner(frameConfig)
@@ -45,36 +49,24 @@ proc start*(self: FrameOS) {.async.} =
     "gpioButtons": self.frameConfig.gpioButtons,
   }}
   self.logger.log(message)
+  netportal.setLogger(self.logger)
 
-  # Check if there's an internet connection or until timeout
-  if self.frameConfig.network.networkCheck and self.frameConfig.network.networkCheckTimeoutSeconds > 0:
-    let url = self.frameConfig.network.networkCheckUrl
-    let timeout = self.frameConfig.network.networkCheckTimeoutSeconds
-    let timer = epochTime()
-    var attempt = 1
-    self.logger.log(%*{"event": "networkCheck", "url": url})
-    while true:
-      if epochTime() - timer >= timeout:
-        self.logger.log(%*{"event": "networkCheck", "status": "timeout", "seconds": timeout})
-        break
-      let client = newHttpClient(timeout = 5000)
-      try:
-        let response = client.get(url)
-        if response.status.startsWith("200"):
-          self.logger.log(%*{"event": "networkCheck", "attempt": attempt, "status": "success"})
-          break
-        else:
-          self.logger.log(%*{"event": "networkCheck", "attempt": attempt, "status": "failed",
-              "response": response.status})
-      except CatchableError as e:
-        self.logger.log(%*{"event": "networkCheck", "attempt": attempt, "status": "error", "error": e.msg})
-      finally:
-        client.close()
-      sleep(attempt * 1000)
-      attempt += 1
+  var firstSceneId: Option[SceneId] = none(SceneId)
+  if self.frameConfig.network.networkCheck:
+    let connected = checkNetwork(self)
+    if self.frameConfig.network.wifiHotspot == "bootOnly":
+      if connected:
+        netportal.stopAp(self)
+      else:
+        netportal.startAp(self)
+        firstSceneId = some("system/wifiHotspot".SceneId)
+  else:
+    self.logger.log(%*{"event": "networkCheck", "status": "skipped"})
 
-  self.runner.start()
-  result = self.server.startServer()
+  self.runner.start(firstSceneId)
+
+  ## This call never returns
+  await self.server.startServer()
 
 proc startFrameOS*() {.async.} =
   var frameOS = newFrameOS()

frameos/src/frameos/logger.nim

@@ -59,10 +59,8 @@ proc processQueue(self: LoggerThread): int =
       self.lastSendAt = epochTime()
       if response.code != Http200:
         echo "Error sending logs: HTTP " & $response.status
-        logToFile(self.frameConfig.logToFile, %*{"error": "Error sending logs", "status": response.status})
     except CatchableError as e:
       echo "Error sending logs: " & $e.msg
-      logToFile(self.frameConfig.logToFile, %*{"error": "Error sending logs", "message": e.msg})
     finally:
       client.close()