goosebit 0.1.0__tar.gz → 0.1.2__tar.gz

goosebit-0.1.2/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: goosebit
+Version: 0.1.2
+Summary: 
+Author: Upstream Data
+Author-email: brett@upstreamdata.ca
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aerich (>=0.7.2,<0.8.0)
+Requires-Dist: aiocache (>=0.12.2,<0.13.0)
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
+Requires-Dist: argon2-cffi (>=23.1.0,<24.0.0)
+Requires-Dist: fastapi[uvicorn] (>=0.111.0,<0.112.0)
+Requires-Dist: itsdangerous (>=2.2.0,<3.0.0)
+Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: joserfc (>=1.0.0,<2.0.0)
+Requires-Dist: libconf (>=2.0.1,<3.0.0)
+Requires-Dist: opentelemetry-distro (>=0.47b0,<0.48)
+Requires-Dist: opentelemetry-exporter-prometheus (>=0.47b0,<0.48)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.47b0,<0.48)
+Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
+Requires-Dist: semver (>=3.0.2,<4.0.0)
+Requires-Dist: tortoise-orm (>=0.21.4,<0.22.0)
+Requires-Dist: websockets (>=12.0,<13.0)
+Description-Content-Type: text/markdown
+
+# gooseBit
+
+<img src="docs/img/goosebit-logo.png" style="width: 100px; height: 100px; display: block;">
+
+---
+
+A simplistic, opinionated remote update server implementing hawkBit™'s [DDI API](https://eclipse.dev/hawkbit/apis/ddi_api/).
+
+## Setup
+
+To set up, install the dependencies in `pyproject.toml` with `poetry install`. Then you can run gooseBit by running `main.py`.
+
+## Initial Startup
+
+The first time you start gooseBit, you should change the default username and password inside `settings.yaml`.
+The default login credentials for testing are `admin@goosebit.local`, `admin`.
+
+## Assumptions
+
+-   [SWUpdate](https://swupdate.org) used on device side.
+
+## Current Feature Set
+
+### Firmware repository
+
+Uploading firmware images through frontend. All files should follow the format `{model}_{revision}_{version}`, where
+`version` is either a semantic version or a datetime version in the format `YYYYMMDD-HHmmSS`.
+
+### Automatic device registration
+
+First time a new device connects, its configuration data is requested. `hw_model` and `hw_revision` are captured from
+the configuration data (both fall back to `default` if not provided) which allows to distinguish different device
+types and their revisions.
+
+### Automatically update device to newest firmware
+
+Once a device is registered it will get the newest available firmware from the repository based on model and revision.
+
+### Manually update device to specific firmware
+
+Frontend allows to assign specific firmware to be rolled out.
+
+### Firmware rollout
+
+Rollouts allow a fine-grained assignment of firmwares to devices. The reported device model and revision is combined
+with the manually set feed and flavor values on a device to determine a matching rollout.
+
+The feed is meant to model either different environments (like: dev, qa, live) or update channels (like. candidate,
+fast, stable).
+
+The flavor can be used for different type of builds (like: debug, prod).
+
+### Pause updates
+
+Device can be pinned to its current firmware.
+
+### Realtime update logs
+
+While an update is running, the update logs are captured and visualized in the frontend.
+
+## Development
+
+### Code formatting and linting
+
+Code is formatted using different tools
+
+-   black and isort for `*.py`
+-   biomejs for `*.js`, `*.json`
+-   prettier for `*.html`, `*.md`, `*.yml`, `*.yaml`
+
+Code is linted using different tools as well
+
+-   flake8 for `*.py`
+-   biomejs for `*.js`
+
+Best to have pre-commit install git hooks that run all those tools before a commit:
+
+```bash
+poetry run pre-commit install
+```
+
+To manually apply the hooks to all files use:
+
+```bash
+pre-commit run --all-files
+```
+
+### Testing
+
+Tests are implemented using pytest. To run all tests
+
+```bash
+poetry run pytest
+```
+

goosebit-0.1.2/README.md

@@ -0,0 +1,94 @@
+# gooseBit
+
+<img src="docs/img/goosebit-logo.png" style="width: 100px; height: 100px; display: block;">
+
+---
+
+A simplistic, opinionated remote update server implementing hawkBit™'s [DDI API](https://eclipse.dev/hawkbit/apis/ddi_api/).
+
+## Setup
+
+To set up, install the dependencies in `pyproject.toml` with `poetry install`. Then you can run gooseBit by running `main.py`.
+
+## Initial Startup
+
+The first time you start gooseBit, you should change the default username and password inside `settings.yaml`.
+The default login credentials for testing are `admin@goosebit.local`, `admin`.
+
+## Assumptions
+
+-   [SWUpdate](https://swupdate.org) used on device side.
+
+## Current Feature Set
+
+### Firmware repository
+
+Uploading firmware images through frontend. All files should follow the format `{model}_{revision}_{version}`, where
+`version` is either a semantic version or a datetime version in the format `YYYYMMDD-HHmmSS`.
+
+### Automatic device registration
+
+First time a new device connects, its configuration data is requested. `hw_model` and `hw_revision` are captured from
+the configuration data (both fall back to `default` if not provided) which allows to distinguish different device
+types and their revisions.
+
+### Automatically update device to newest firmware
+
+Once a device is registered it will get the newest available firmware from the repository based on model and revision.
+
+### Manually update device to specific firmware
+
+Frontend allows to assign specific firmware to be rolled out.
+
+### Firmware rollout
+
+Rollouts allow a fine-grained assignment of firmwares to devices. The reported device model and revision is combined
+with the manually set feed and flavor values on a device to determine a matching rollout.
+
+The feed is meant to model either different environments (like: dev, qa, live) or update channels (like. candidate,
+fast, stable).
+
+The flavor can be used for different type of builds (like: debug, prod).
+
+### Pause updates
+
+Device can be pinned to its current firmware.
+
+### Realtime update logs
+
+While an update is running, the update logs are captured and visualized in the frontend.
+
+## Development
+
+### Code formatting and linting
+
+Code is formatted using different tools
+
+-   black and isort for `*.py`
+-   biomejs for `*.js`, `*.json`
+-   prettier for `*.html`, `*.md`, `*.yml`, `*.yaml`
+
+Code is linted using different tools as well
+
+-   flake8 for `*.py`
+-   biomejs for `*.js`
+
+Best to have pre-commit install git hooks that run all those tools before a commit:
+
+```bash
+poetry run pre-commit install
+```
+
+To manually apply the hooks to all files use:
+
+```bash
+pre-commit run --all-files
+```
+
+### Testing
+
+Tests are implemented using pytest. To run all tests
+
+```bash
+poetry run pytest
+```

{goosebit-0.1.0 → goosebit-0.1.2}/goosebit/__init__.py

@@ -5,8 +5,9 @@ from fastapi import Depends, FastAPI
 from fastapi.requests import Request
 from fastapi.responses import RedirectResponse
 from fastapi.security import OAuth2PasswordRequestForm
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor as Instrumentor
 
-from goosebit import api, db, realtime, ui, updater
+from goosebit import api, db, realtime, telemetry, ui, updater
 from goosebit.auth import (
     authenticate_user,
     auto_redirect,
@@ -20,6 +21,7 @@ from goosebit.ui.templates import templates
 @asynccontextmanager
 async def lifespan(_: FastAPI):
     await db.init()
+    await telemetry.init()
     yield
     await db.close()
 
@@ -30,6 +32,7 @@ app.include_router(ui.router)
 app.include_router(api.router)
 app.include_router(realtime.router)
 app.mount("/static", static, name="static")
+Instrumentor.instrument_app(app)
 
 
 @app.middleware("http")
@@ -45,18 +48,18 @@ def root_redirect(request: Request):
 
 @app.get("/login", dependencies=[Depends(auto_redirect)], include_in_schema=False)
 async def login_ui(request: Request):
-    return templates.TemplateResponse("login.html", context={"request": request})
+    return templates.TemplateResponse(request, "login.html")
 
 
 @app.post("/login", include_in_schema=False, dependencies=[Depends(authenticate_user)])
-async def login(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
-    resp = RedirectResponse("/ui/home", status_code=302)
+async def login(request: Request, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
+    resp = RedirectResponse(request.url_for("ui_root"), status_code=302)
     resp.set_cookie(key="session_id", value=create_session(form_data.username))
     return resp
 
 
 @app.get("/logout", include_in_schema=False)
 async def logout(request: Request):
-    resp = RedirectResponse("/login", status_code=302)
+    resp = RedirectResponse(request.url_for("login_ui"), status_code=302)
     resp.delete_cookie(key="session_id")
     return resp

goosebit-0.1.2/goosebit/api/__init__.py

@@ -0,0 +1 @@
+from .routes import router  # noqa: F401

goosebit-0.1.2/goosebit/api/devices.py

@@ -0,0 +1,136 @@
+import time
+from typing import Any
+
+from fastapi import APIRouter, Security
+from fastapi.requests import Request
+from pydantic import BaseModel
+from tortoise.expressions import Q
+
+from goosebit.api.helper import filter_data
+from goosebit.auth import validate_user_permissions
+from goosebit.models import Device, Firmware, UpdateModeEnum, UpdateStateEnum
+from goosebit.permissions import Permissions
+from goosebit.updater.manager import delete_devices, get_update_manager
+
+router = APIRouter(prefix="/devices")
+
+
+@router.get(
+    "/all",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.HOME.READ])],
+)
+async def devices_get_all(request: Request) -> dict[str, int | list[Any] | Any]:
+    query = Device.all().prefetch_related("assigned_firmware", "hardware")
+
+    def search_filter(search_value):
+        return (
+            Q(uuid__icontains=search_value)
+            | Q(name__icontains=search_value)
+            | Q(feed__icontains=search_value)
+            | Q(flavor__icontains=search_value)
+            | Q(update_mode__icontains=UpdateModeEnum.from_str(search_value))
+            | Q(last_state__icontains=UpdateStateEnum.from_str(search_value))
+        )
+
+    async def parse(device: Device) -> dict:
+        manager = await get_update_manager(device.uuid)
+        _, target_firmware = await manager.get_update()
+        last_seen = device.last_seen
+        if last_seen is not None:
+            last_seen = round(time.time() - device.last_seen)
+        return {
+            "uuid": device.uuid,
+            "name": device.name,
+            "fw_installed_version": device.fw_version,
+            "fw_target_version": (target_firmware.version if target_firmware is not None else None),
+            "fw_assigned": (device.assigned_firmware.id if device.assigned_firmware is not None else None),
+            "hw_model": device.hardware.model,
+            "hw_revision": device.hardware.revision,
+            "feed": device.feed,
+            "flavor": device.flavor,
+            "progress": device.progress,
+            "state": str(device.last_state),
+            "update_mode": str(device.update_mode),
+            "force_update": device.force_update,
+            "last_ip": device.last_ip,
+            "last_seen": last_seen,
+            "online": (last_seen < manager.poll_seconds if last_seen is not None else None),
+        }
+
+    total_records = await Device.all().count()
+    return await filter_data(request, query, search_filter, parse, total_records)
+
+
+class UpdateDevicesModel(BaseModel):
+    devices: list[str]
+    firmware: str | None = None
+    name: str | None = None
+    pinned: bool | None = None
+    feed: str | None = None
+    flavor: str | None = None
+
+
+@router.post(
+    "/update",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.DEVICE.WRITE])],
+)
+async def devices_update(_: Request, config: UpdateDevicesModel) -> dict:
+    for uuid in config.devices:
+        updater = await get_update_manager(uuid)
+        if config.firmware is not None:
+            if config.firmware == "rollout":
+                await updater.update_update(UpdateModeEnum.ROLLOUT, None)
+            elif config.firmware == "latest":
+                await updater.update_update(UpdateModeEnum.LATEST, None)
+            else:
+                firmware = await Firmware.get_or_none(id=config.firmware)
+                await updater.update_update(UpdateModeEnum.ASSIGNED, firmware)
+        if config.pinned is not None:
+            await updater.update_update(UpdateModeEnum.PINNED, None)
+        if config.name is not None:
+            await updater.update_name(config.name)
+        if config.feed is not None:
+            await updater.update_feed(config.feed)
+        if config.flavor is not None:
+            await updater.update_flavor(config.flavor)
+    return {"success": True}
+
+
+class ForceUpdateModel(BaseModel):
+    devices: list[str]
+
+
+@router.post(
+    "/force_update",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.DEVICE.WRITE])],
+)
+async def devices_force_update(_: Request, config: ForceUpdateModel) -> dict:
+    for uuid in config.devices:
+        updater = await get_update_manager(uuid)
+        await updater.update_force_update(True)
+    return {"success": True}
+
+
+@router.get(
+    "/logs/{dev_id}",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.HOME.READ])],
+)
+async def device_logs(_: Request, dev_id: str) -> str:
+    updater = await get_update_manager(dev_id)
+    device = await updater.get_device()
+    if device.last_log is not None:
+        return device.last_log
+    return "No logs found."
+
+
+class DeleteModel(BaseModel):
+    devices: list[str]
+
+
+@router.post(
+    "/delete",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.DEVICE.DELETE])],
+)
+async def devices_delete(_: Request, config: DeleteModel) -> dict:
+    await delete_devices(config.devices)
+    return {"success": True}

goosebit-0.1.2/goosebit/api/download.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.requests import Request
+from fastapi.responses import FileResponse, RedirectResponse
+from starlette.responses import Response
+
+from goosebit.models import Firmware
+
+router = APIRouter(prefix="/download")
+
+
+@router.head("/{file_id}")
+async def download_file_head(_: Request, file_id: int):
+    firmware = await Firmware.get_or_none(id=file_id)
+    if firmware is None:
+        raise HTTPException(404)
+
+    response = Response()
+    response.headers["Content-Length"] = str(firmware.size)
+    return response
+
+
+@router.get("/{file_id}")
+async def download_file(_: Request, file_id: int):
+    firmware = await Firmware.get_or_none(id=file_id)
+    if firmware is None:
+        raise HTTPException(404)
+    if firmware.local:
+        return FileResponse(
+            firmware.path,
+            media_type="application/octet-stream",
+            filename=firmware.path.name,
+        )
+    else:
+        return RedirectResponse(url=firmware.uri)

goosebit-0.1.2/goosebit/api/firmware.py

@@ -0,0 +1,57 @@
+from typing import Any
+
+from fastapi import APIRouter, Body, Security
+from fastapi.requests import Request
+from tortoise.expressions import Q
+
+from goosebit.api.helper import filter_data
+from goosebit.auth import validate_user_permissions
+from goosebit.models import Firmware
+from goosebit.permissions import Permissions
+
+router = APIRouter(prefix="/firmware")
+
+
+@router.get(
+    "/all",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.FIRMWARE.READ])],
+)
+async def firmware_get_all(
+    request: Request,
+) -> dict[str, int | list[dict[str, list[Any] | Any]]]:
+    query = Firmware.all()
+
+    def search_filter(search_value):
+        return Q(uri__icontains=search_value) | Q(version__icontains=search_value)
+
+    async def parse(f):
+        return {
+            "id": f.id,
+            "name": f.path.name,
+            "size": f.size,
+            "hash": f.hash,
+            "version": f.version,
+            "compatibility": list(await f.compatibility.all().values()),
+        }
+
+    total_records = await Firmware.all().count()
+    return await filter_data(request, query, search_filter, parse, total_records)
+
+
+@router.post(
+    "/delete",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.FIRMWARE.DELETE])],
+)
+async def firmware_delete(_: Request, files: list[int] = Body()) -> dict:
+    success = False
+    for f_id in files:
+        firmware = await Firmware.get_or_none(id=f_id)
+        if firmware is None:
+            continue
+        if firmware.local:
+            path = firmware.path
+            if path.exists():
+                path.unlink()
+        await firmware.delete()
+        success = True
+    return {"success": success}

goosebit-0.1.2/goosebit/api/helper.py

@@ -0,0 +1,30 @@
+import asyncio
+
+
+async def filter_data(request, query, search_filter, parse, total_records):
+    params = request.query_params
+
+    draw = int(params.get("draw", 1))
+    start = int(params.get("start", 0))
+    length = int(params.get("length", 10))
+    search_value = params.get("search[value]", None)
+    order_column_index = params.get("order[0][column]", None)
+    order_column = params.get(f"columns[{order_column_index}][data]", None)
+    order_dir = params.get("order[0][dir]", None)
+
+    if search_value:
+        query = query.filter(search_filter(search_value))
+
+    if order_column:
+        query = query.order_by(f"{"-" if order_dir == "desc" else ""}{order_column}")
+
+    filtered_records = await query.count()
+    rollouts = await query.offset(start).limit(length).all()
+    data = list(await asyncio.gather(*[parse(r) for r in rollouts]))
+
+    return {
+        "draw": draw,
+        "recordsTotal": total_records,
+        "recordsFiltered": filtered_records,
+        "data": data,
+    }

goosebit-0.1.2/goosebit/api/rollouts.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, Security
+from fastapi.requests import Request
+from pydantic import BaseModel
+from tortoise.expressions import Q
+
+from goosebit.api.helper import filter_data
+from goosebit.auth import validate_user_permissions
+from goosebit.models import Rollout
+from goosebit.permissions import Permissions
+
+router = APIRouter(prefix="/rollouts")
+
+
+@router.get(
+    "/all",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.ROLLOUT.READ])],
+)
+async def rollouts_get_all(request: Request) -> dict[str, int | list[dict]]:
+    query = Rollout.all().prefetch_related("firmware")
+
+    def search_filter(search_value):
+        return Q(name__icontains=search_value) | Q(feed__icontains=search_value) | Q(flavor__icontains=search_value)
+
+    async def parse(rollout: Rollout) -> dict:
+        return {
+            "id": rollout.id,
+            "created_at": int(rollout.created_at.timestamp() * 1000),
+            "name": rollout.name,
+            "feed": rollout.feed,
+            "flavor": rollout.flavor,
+            "fw_file": rollout.firmware.path.name,
+            "fw_version": rollout.firmware.version,
+            "paused": rollout.paused,
+            "success_count": rollout.success_count,
+            "failure_count": rollout.failure_count,
+        }
+
+    total_records = await Rollout.all().count()
+    return await filter_data(request, query, search_filter, parse, total_records)
+
+
+class CreateRolloutsModel(BaseModel):
+    name: str
+    feed: str
+    flavor: str
+    firmware_id: int
+
+
+@router.post(
+    "/",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.ROLLOUT.WRITE])],
+)
+async def rollouts_create(_: Request, rollout: CreateRolloutsModel) -> dict:
+    rollout = await Rollout.create(
+        name=rollout.name,
+        feed=rollout.feed,
+        flavor=rollout.flavor,
+        firmware_id=rollout.firmware_id,
+    )
+    return {"success": True, "id": rollout.id}
+
+
+class UpdateRolloutsModel(BaseModel):
+    ids: list[int]
+    paused: bool
+
+
+@router.post(
+    "/update",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.ROLLOUT.WRITE])],
+)
+async def rollouts_update(_: Request, rollouts: UpdateRolloutsModel) -> dict:
+    await Rollout.filter(id__in=rollouts.ids).update(paused=rollouts.paused)
+    return {"success": True}
+
+
+class DeleteRolloutsModel(BaseModel):
+    ids: list[int]
+
+
+@router.post(
+    "/delete",
+    dependencies=[Security(validate_user_permissions, scopes=[Permissions.ROLLOUT.DELETE])],
+)
+async def rollouts_delete(_: Request, rollouts: DeleteRolloutsModel) -> dict:
+    await Rollout.filter(id__in=rollouts.ids).delete()
+    return {"success": True}

goosebit-0.1.2/goosebit/api/routes.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter, Depends
+
+from goosebit.api import devices, download, firmware, rollouts
+from goosebit.auth import authenticate_api_session
+
+# main router that requires authentication
+main_router = APIRouter(prefix="/api", dependencies=[Depends(authenticate_api_session)], tags=["api"])
+main_router.include_router(firmware.router)
+main_router.include_router(devices.router)
+main_router.include_router(rollouts.router)
+
+# download router without authentication
+download_router = APIRouter(prefix="/api", tags=["api"])
+download_router.include_router(download.router)
+
+# include both routers
+router = APIRouter()
+router.include_router(main_router)
+router.include_router(download_router)