goosebit 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

goosebit/ui/templates/devices.html

@@ -15,6 +15,12 @@
                         <th>
                             UUID
                         </th>
+                        <th>
+                            Model
+                        </th>
+                        <th>
+                            Revision
+                        </th>
                         <th>
                             Firmware
                         </th>
@@ -24,6 +30,9 @@
                         <th>
                             Update File
                         </th>
+                        <th>
+                            Progress
+                        </th>
                         <th>
                             Last IP
                         </th>

goosebit/ui/templates/firmware.html

@@ -19,6 +19,8 @@
                             </div>
                             <h3>Upload Progress</h3>
                             <div class="col">
+                                <div id="upload-alerts">
+                                </div>
                                 <div class="progress w-100" style=" height: 40px;" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100">
                                     <div class="progress-bar progress-bar-striped progress-bar-animated" id="upload-progress" style="width: 0%;">0%</div>
                                 </div>

goosebit/ui/templates/index.html

@@ -18,6 +18,9 @@
                         <th>
                             Firmware
                         </th>
+                        <th>
+                            Progress
+                        </th>
                         <th>
                             Last IP
                         </th>

goosebit/ui/templates/logs.html

@@ -7,6 +7,11 @@
                 <div class="card-header">
                     <h3>Logs - {{ device }}</h3>
                 </div>
+                <div class="card-header">
+                    <div class="progress m-2" role="progressbar" aria-label="Basic example" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100">
+                        <div class="progress-bar progress-bar-striped progress-bar-animated" id="install-progress" style="width: 0%"></div>
+                    </div>
+                </div>
                 <div class="card-body">
                     <pre id="device-log"></pre>
                 </div>

goosebit/ui/templates/nav.html

@@ -34,7 +34,7 @@
             <div class="container-fluid">
                 <a class="navbar-brand" href="/ui/home">
                     <img src="{{ request.url_for('static', path='svg/goosebit-logo.svg') }}" class="me-2" style="height:30px; width: 30px;"/>
-                    GooseBit
+                    gooseBit
                 </a>
                 <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
                     <span class="navbar-toggler-icon"></span>
@@ -50,7 +50,9 @@
                         {% if "devices.read" in request.user.permissions %}
                             <a class="nav-link{% if request.url.path.endswith('devices') %} active{% endif %}" href="/ui/devices">Devices</a>
                         {% endif %}
-
+                        {% if "rollouts.read" in request.user.permissions %}
+                            <a class="nav-link{% if request.url.path.endswith('rollouts') %} active{% endif %}" href="/ui/rollouts">Rollouts</a>
+                        {% endif %}
                     </div>
                     <div class="navbar-nav d-flex flex-fill justify-content-end">
                         <a class="nav-link" href="/logout">Logout<i class="bi bi-box-arrow-right ps-2"></i></a>

goosebit/ui/templates/rollouts.html

@@ -0,0 +1,53 @@
+{% extends "nav.html" %}
+{% block content %}
+<div class="container-fluid">
+    <div class="row p-2 d-flex justify-content-center">
+        <div class="col">
+            <table id="rollout-table" class="table table-hover">
+                <thead>
+                    <tr>
+                        <th>
+                            Id
+                        </th>
+                        <th>
+                            Created
+                        </th>
+                        <th>
+                            Name
+                        </th>
+                        <th>
+                            Model
+                        </th>
+                        <th>
+                            Revision
+                        </th>
+                        <th>
+                            Feed
+                        </th>
+                        <th>
+                            Flavour
+                        </th>
+                        <th>
+                            Update File
+                        </th>
+                        <th>
+                            Paused
+                        </th>
+                        <th>
+                            Success Count
+                        </th>
+                        <th>
+                            Failure Count
+                        </th>
+                    </tr>
+                </thead>
+                <tbody id="rollouts-list">
+
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+
+<script src="{{ url_for('static', path='js/rollouts.js') }}"></script>
+{% endblock content %}

goosebit/updater/controller/v1/routes.py

@@ -3,6 +3,7 @@ import json
 from fastapi import APIRouter, Depends
 from fastapi.requests import Request
 
+from goosebit.settings import POLL_TIME_REGISTRATION
 from goosebit.updater.manager import UpdateManager, get_update_manager
 
 # v1 is hardware revision
@@ -16,17 +17,47 @@ async def polling(
     dev_id: str,
     updater: UpdateManager = Depends(get_update_manager),
 ):
-    return {
-        "config": {"polling": {"sleep": updater.poll_time}},
-        "_links": {
-            "deploymentBase": {
+    links = {}
+
+    sleep = updater.poll_time
+    last_state = updater.device.last_state
+
+    if last_state == "unknown":
+        # device registration
+        sleep = POLL_TIME_REGISTRATION
+        links["configData"] = {
+            "href": str(
+                request.url_for(
+                    "config_data",
+                    tenant=tenant,
+                    dev_id=dev_id,
+                )
+            )
+        }
+
+    elif last_state == "error" and not updater.force_update:
+        # nothing to do
+        pass
+
+    else:
+        # provide update if available. Note: this is also required while in state "running", otherwise swupdate
+        # won't confirm a successful testing (might be a bug/problem in swupdate)
+        update = await updater.get_update_mode()
+        if update != "skip":
+            links["deploymentBase"] = {
                 "href": str(
                     request.url_for(
-                        "deployment_base", tenant=tenant, dev_id=dev_id, action_id=1
+                        "deployment_base",
+                        tenant=tenant,
+                        dev_id=dev_id,
+                        action_id=1,
                     )
                 )
-            },
-        },
+            }
+
+    return {
+        "config": {"polling": {"sleep": sleep}},
+        "_links": links,
     }
 
 
@@ -34,11 +65,12 @@ async def polling(
 async def config_data(
     request: Request,
     dev_id: str,
+    tenant: str,
     updater: UpdateManager = Depends(get_update_manager),
 ):
     data = await request.json()
     # TODO: make standard schema to deal with this
-    print(data)
+    await updater.update_config_data(**data["data"])
     return {"success": True, "message": "Updated swupdate data."}
 
 
@@ -77,8 +109,46 @@ async def deployment_feedback(
     except json.JSONDecodeError:
         return
     try:
-        state = data["status"]["result"]["finished"]
-        await updater.update_device_state(state)
+        execution = data["status"]["execution"]
+
+        if execution == "proceeding":
+            await updater.update_device_state("running")
+
+        elif execution == "closed":
+            state = data["status"]["result"]["finished"]
+
+            updater.force_update = False
+            updater.update_complete = True
+
+            # From hawkBit docu: DDI defines also a status NONE which will not be interpreted by the update server
+            # and handled like SUCCESS.
+            if state == "success" or state == "none":
+                await updater.update_device_state("finished")
+
+                # not guaranteed to be the correct rollout - see next comment.
+                rollout = await updater.get_rollout()
+                if rollout:
+                    file = rollout.fw_file
+                    rollout.success_count += 1
+                    await rollout.save()
+                else:
+                    device = await updater.get_device()
+                    file = device.fw_file
+
+                # setting the currently installed version based on the current assigned firmware / existing rollouts
+                # is problematic. Better to assign custom action_id for each update (rollout id? firmware id? new id?).
+                # Alternatively - but requires customization on the gateway side - use version reported by the gateway.
+                await updater.update_fw_version(file)
+
+            elif state == "failure":
+                await updater.update_device_state("error")
+
+                # not guaranteed to be the correct rollout - see comment above.
+                rollout = await updater.get_rollout()
+                if rollout:
+                    rollout.failure_count += 1
+                    await rollout.save()
+
     except KeyError:
         pass
 

goosebit/updater/download/v1/routes.py

@@ -1,9 +1,8 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter
 from fastapi.requests import Request
 from fastapi.responses import FileResponse
 
-from goosebit.settings import TOKEN_SWU_DIR, UPDATES_DIR
-from goosebit.updater.manager import UpdateManager, get_update_manager
+from goosebit.settings import UPDATES_DIR
 
 router = APIRouter(prefix="/v1")
 
@@ -12,15 +11,3 @@ router = APIRouter(prefix="/v1")
 async def download_file(request: Request, tenant: str, dev_id: str, file: str):
     filename = UPDATES_DIR.joinpath(file)
     return FileResponse(filename, media_type="application/octet-stream")
-
-
-@router.get("/{dev_id}/cfd_conf/{file}")
-async def download_cfd_conf(
-    request: Request,
-    tenant: str,
-    dev_id: str,
-    file: str,
-    updater: UpdateManager = Depends(get_update_manager),
-):
-    filename = TOKEN_SWU_DIR.joinpath(dev_id, file)
-    return FileResponse(filename, media_type="application/octet-stream")

goosebit/updater/manager.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
 import asyncio
+import re
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
-from typing import Callable
+from datetime import datetime
+from typing import Callable, Optional
 
-import aiofiles
-
-from goosebit.models import Device
-from goosebit.settings import POLL_TIME, SWUPDATE_FILES_DIR, TOKEN_SWU_DIR
-from goosebit.updater.misc import get_newest_fw
-from goosebit.updater.updates import FirmwareArtifact
+from goosebit.models import Device, Rollout
+from goosebit.settings import POLL_TIME, POLL_TIME_UPDATING
+from goosebit.updates.artifacts import FirmwareArtifact
 
 
 class UpdateManager(ABC):
     def __init__(self, dev_id: str):
         self.dev_id = dev_id
+        self.config_data = {}
         self.device = None
         self.force_update = False
         self.update_complete = False
@@ -31,26 +31,34 @@ class UpdateManager(ABC):
     async def update_fw_version(self, version: str) -> None:
         return
 
-    async def update_device_state(self, state: str) -> None:
+    async def update_hw_model(self, hw_model: str) -> None:
         return
 
-    async def update_last_seen(self, last_seen: int) -> None:
+    async def update_hw_revision(self, hw_revision: str) -> None:
         return
 
-    async def update_web_pwd(self, web_pwd: str) -> None:
+    async def update_device_state(self, state: str) -> None:
         return
 
-    async def update_last_ip(self, last_ip: str) -> None:
+    async def update_last_seen(self, last_seen: int) -> None:
         return
 
-    async def update_cfd_status(self, status: bool) -> None:
+    async def update_last_ip(self, last_ip: str) -> None:
         return
 
-    async def create_cfd_token(self) -> str:
-        return ""
+    async def get_rollout(self) -> Optional[Rollout]:
+        return None
 
-    async def delete_cfd_token(self):
-        return
+    async def update_config_data(self, **kwargs):
+        await self.update_hw_model(kwargs.get("hw_model") or "default")
+        await self.update_hw_revision(kwargs.get("hw_revision") or "default")
+
+        device = await self.get_device()
+        if device.last_state == "unknown":
+            await self.update_device_state("registered")
+        await self.save()
+
+        self.config_data.update(kwargs)
 
     @asynccontextmanager
     async def subscribe_log(self, callback: Callable):
@@ -64,14 +72,15 @@ class UpdateManager(ABC):
         finally:
             self.log_subscribers.remove(callback)
 
+    @property
+    def poll_seconds(self):
+        time_obj = datetime.strptime(self.poll_time, "%H:%M:%S")
+        return time_obj.hour * 3600 + time_obj.minute * 60 + time_obj.second
+
     async def publish_log(self, log_data: str | None):
         for cb in self.log_subscribers:
             await cb(log_data)
 
-    @property
-    def cfd_provisioned(self) -> bool:
-        return False
-
     @abstractmethod
     async def get_update_file(self) -> FirmwareArtifact: ...
 
@@ -85,10 +94,10 @@ class UpdateManager(ABC):
 class UnknownUpdateManager(UpdateManager):
     def __init__(self, dev_id: str):
         super().__init__(dev_id)
-        self.poll_time = "00:00:05"
+        self.poll_time = POLL_TIME_UPDATING
 
     async def get_update_file(self) -> FirmwareArtifact:
-        return FirmwareArtifact(get_newest_fw())
+        return FirmwareArtifact("latest")
 
     async def get_update_mode(self) -> str:
         return "forced"
@@ -111,6 +120,14 @@ class DeviceUpdateManager(UpdateManager):
         device = await self.get_device()
         device.fw_version = version
 
+    async def update_hw_model(self, hw_model: str) -> None:
+        device = await self.get_device()
+        device.hw_model = hw_model
+
+    async def update_hw_revision(self, hw_revision: str) -> None:
+        device = await self.get_device()
+        device.hw_revision = hw_revision
+
     async def update_device_state(self, state: str) -> None:
         device = await self.get_device()
         device.last_state = state
@@ -126,13 +143,33 @@ class DeviceUpdateManager(UpdateManager):
         else:
             device.last_ip = last_ip
 
+    async def get_rollout(self) -> Optional[Rollout]:
+        device = await self.get_device()
+
+        if device.fw_file == "none":
+            return (
+                await Rollout.filter(
+                    hw_model=device.hw_model,
+                    hw_revision=device.hw_revision,
+                    feed=device.feed,
+                    flavor=device.flavor,
+                )
+                .order_by("-created_at")
+                .first()
+            )
+
+        return None
+
     async def get_update_file(self) -> FirmwareArtifact:
         device = await self.get_device()
-        file = FirmwareArtifact(device.fw_file)
+        file = device.fw_file
+
+        if file == "none":
+            rollout = await self.get_rollout()
+            if rollout and not rollout.paused:
+                file = rollout.fw_file
 
-        if self.force_update:
-            return file
-        return file
+        return FirmwareArtifact(file, device.hw_model, device.hw_revision)
 
     async def get_update_mode(self) -> str:
         device = await self.get_device()
@@ -141,20 +178,19 @@ class DeviceUpdateManager(UpdateManager):
         if file.is_empty():
             mode = "skip"
             self.poll_time = POLL_TIME
-        elif file.name == device.fw_version:
+        elif file.name == device.fw_version and not self.force_update:
+            mode = "skip"
+            self.poll_time = POLL_TIME
+        elif device.last_state == "error" and not self.force_update:
             mode = "skip"
             self.poll_time = POLL_TIME
         else:
             mode = "forced"
-            self.poll_time = "00:00:05"
+            self.poll_time = POLL_TIME_UPDATING
 
-        if self.force_update:
-            mode = "forced"
-            self.poll_time = "00:00:05"
-
-        if mode == "forced" and self.update_complete:
-            self.update_complete = False
-            await self.clear_log()
+            if self.update_complete:
+                self.update_complete = False
+                await self.clear_log()
 
         return mode
 
@@ -162,6 +198,9 @@ class DeviceUpdateManager(UpdateManager):
         if log_data is None:
             return
         device = await self.get_device()
+        matches = re.findall(r"Downloaded (\d+)%", log_data)
+        if matches:
+            device.progress = matches[-1]
         if device.last_log is None:
             device.last_log = ""
         if log_data.startswith("Installing Update Chunk Artifacts."):
@@ -172,10 +211,12 @@ class DeviceUpdateManager(UpdateManager):
         if not log_data == "Skipped Update.":
             device.last_log += f"{log_data}\n"
             await self.publish_log(f"{log_data}\n")
+        await device.save()
 
     async def clear_log(self) -> None:
         device = await self.get_device()
         device.last_log = ""
+        await device.save()
         await self.publish_log(None)
 
 

goosebit/updater/misc.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import datetime
 import hashlib
 from pathlib import Path
+from typing import Optional
 
 from goosebit.models import Device
-from goosebit.settings import UPDATES_DIR
+from goosebit.settings import UPDATE_VERSION_PARSER, UPDATES_DIR
 
 
 def sha1_hash_file(file_path: Path):
@@ -14,46 +14,34 @@ def sha1_hash_file(file_path: Path):
     return sha1_hash.hexdigest()
 
 
-def get_newest_fw() -> str:
-    fw_files = [f for f in UPDATES_DIR.iterdir() if f.suffix == ".swu"]
+def get_newest_fw(hw_model: str, hw_revision: str) -> Optional[str]:
+    def filter_filename(filename, hw_model, hw_revision) -> bool:
+        image_data = filename.split("_")
+        assert len(image_data) == 3
+        model, revision, _ = image_data
+        return model == hw_model and revision == hw_revision
+
+    fw_files = [
+        f
+        for f in UPDATES_DIR.iterdir()
+        if f.suffix == ".swu" and filter_filename(f.name, hw_model, hw_revision)
+    ]
     if len(fw_files) == 0:
-        return ""
+        return None
 
     return str(sorted(fw_files, key=lambda x: fw_sort_key(x), reverse=True)[0].name)
 
 
-def fw_sort_key(filename: Path) -> datetime.datetime:
-    image_data = filename.stem.split("_")
-    if len(image_data) == 3:
-        tenant, date, time = image_data
-    elif len(image_data) == 4:
-        tenant, hw_version, date, time = image_data
-    else:
-        return datetime.datetime.now()
-
-    return datetime.datetime.strptime(f"{date}_{time}", "%Y%m%d_%H%M%S")
+def validate_filename(filename: str) -> bool:
+    try:
+        fw_sort_key(Path(filename))
+        return True
+    except ValueError:
+        return False
 
 
-def get_fw_components(filename: Path) -> dict:
-    image_data = filename.stem.split("_")
-    if len(image_data) == 3:
-        tenant, date, time = image_data
-        return {
-            "date": datetime.datetime.strptime(f"{date}_{time}", "%Y%m%d_%H%M%S"),
-            "day": date,
-            "time": time,
-            "tenant": tenant,
-            "hw_version": 0,
-        }
-    elif len(image_data) == 4:
-        tenant, hw_version, date, time = image_data
-        return {
-            "date": datetime.datetime.strptime(f"{date}_{time}", "%Y%m%d_%H%M%S"),
-            "day": date,
-            "time": time,
-            "tenant": tenant,
-            "hw_version": int(hw_version.upper().replace("V", "")),
-        }
+def fw_sort_key(filename: Path):
+    return UPDATE_VERSION_PARSER.parse(filename)
 
 
 async def get_device_by_uuid(dev_id: str) -> Device:

goosebit/updater/routes.py

@@ -3,12 +3,14 @@ import time
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.requests import Request
 
+from goosebit.settings import TENANT
+
 from . import controller, download
 from .manager import get_update_manager_sync
 
 
 async def verify_tenant(tenant: str):
-    if not tenant == "loadsync":
+    if not tenant == TENANT:
         raise HTTPException(404)
     return tenant
 

goosebit/{updater/updates.py → updates/artifacts.py}

@@ -4,19 +4,20 @@ from typing import Optional
 
 from fastapi.requests import Request
 
-from goosebit.settings import TOKEN_SWU_DIR, UPDATES_DIR
+from goosebit.settings import UPDATES_DIR
 from goosebit.updater.misc import get_newest_fw, sha1_hash_file
 
 
 class FirmwareArtifact:
-    def __init__(self, file: str = None, dev_id: str = None):
+    def __init__(self, file: str = None, hw_model: str = None, hw_revision: str = None):
         if file == "latest":
-            self.file = get_newest_fw()
+            self.file = get_newest_fw(hw_model, hw_revision)
         elif file == "pinned":
             self.file = None
+        elif file == "none":
+            self.file = None
         else:
             self.file = file
-        self.dev_id = dev_id
 
     def __eq__(self, other):
         if isinstance(other, str):
@@ -31,19 +32,18 @@ class FirmwareArtifact:
     def file_exists(self) -> bool:
         if self.is_empty():
             return False
-        if self.file == "cloudflared.swu":
-            return True
         return self.path.exists()
 
     @property
-    def name(self):
-        if not self.is_empty():
-            return self.file.split(".")[0]
+    def name(self) -> Optional[str]:
+        return self.file
 
     @property
     def version(self):
         if not self.is_empty():
-            return "_".join(self.name.split("_")[2:])
+            image_data = self.name.split("_")
+            assert len(image_data) == 3
+            return "_".join(image_data[1:])
 
     @property
     def timestamp(self):
@@ -52,14 +52,10 @@ class FirmwareArtifact:
     @property
     def path(self) -> Optional[Path]:
         if not self.is_empty():
-            if self.file == "cloudflared.swu":
-                return TOKEN_SWU_DIR.joinpath(self.dev_id, self.file)
             return UPDATES_DIR.joinpath(self.file)
 
     @property
     def dl_endpoint(self):
-        if self.file == "cloudflared.swu":
-            return "download_cfd_conf"
         return "download_file"
 
     def generate_chunk(self, request: Request, tenant: str, dev_id: str) -> list: