goosebit 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

goosebit-0.2.1.dist-info/RECORD

@@ -0,0 +1,95 @@
+goosebit/__init__.py,sha256=vhOcvSYVWRttpjBDeAVftUHZPVaLExvqFEV9LU69vgc,3039
+goosebit/__main__.py,sha256=ezSLOobcrbnBspFOSbyjuATEdk8B3aAj9cgEu647ujk,161
+goosebit/api/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/api/responses.py,sha256=HXLpFgL-iv5Ts6LKa3AMt1XGV1GbDE5GzjK66_3Gz5o,84
+goosebit/api/routes.py,sha256=KOA1r8Ripl9nhZV4gZpuQrRi0fG9I3VEqcAAMeBGqBk,272
+goosebit/api/telemetry/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/api/telemetry/metrics.py,sha256=aJ2viqBcxU41wJ0tDwPXj0Dsv6YEHaWv7EBDqkUilGI,791
+goosebit/api/telemetry/prometheus/__init__.py,sha256=nvVtx3DsqBhoXE4Y4L6k7nYoQTl1VV0afyVW2YHLQGs,83
+goosebit/api/telemetry/prometheus/readers.py,sha256=TKD7LT-lYS53xdt-tLMxqyWAeya62299cJtok9Q2MSE,104
+goosebit/api/telemetry/prometheus/routes.py,sha256=91TNk_pbxi5BfCLo_OVojubL9kxFuL84dJ55RmsZ0eE,676
+goosebit/api/telemetry/routes.py,sha256=nuv9bClyo_P8TAkcp3huqxZoUn-ATlRAMnl0OXbWNpw,217
+goosebit/api/v1/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/api/v1/devices/__init__.py,sha256=kzt5TBA-bJmDZFXYPohggbMOW7GhklyflaRKZNC0yDY,42
+goosebit/api/v1/devices/device/__init__.py,sha256=kzt5TBA-bJmDZFXYPohggbMOW7GhklyflaRKZNC0yDY,42
+goosebit/api/v1/devices/device/responses.py,sha256=THIPMzc6mwl7GmIXuqAeLLesFHfssvPrMJeHe8tV4mA,222
+goosebit/api/v1/devices/device/routes.py,sha256=Q9v7NzTFGdwQQmSRjGsFXl9qDwilVB1ieG9isXLaXgs,957
+goosebit/api/v1/devices/requests.py,sha256=zx9eWXQanqBnmy-XboA_lrzInfx9ozOB4vG2jRTwnJA,131
+goosebit/api/v1/devices/responses.py,sha256=m1S0DfseNhlJ0mlw8J5msmXrdftUC0oZbwciy8eNfvY,402
+goosebit/api/v1/devices/routes.py,sha256=D6w6vq0XkRGMaE-QHHLNPPi5kiZ8JufdHFTyar1XH8s,1051
+goosebit/api/v1/download/__init__.py,sha256=kzt5TBA-bJmDZFXYPohggbMOW7GhklyflaRKZNC0yDY,42
+goosebit/api/v1/download/routes.py,sha256=wdeXA-dGO4D9FxaUP6OnUSW4_2NZhi_VgIxMcSRL2x4,675
+goosebit/api/v1/rollouts/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/api/v1/rollouts/requests.py,sha256=EF1VUwaK-f-2SSKxl2klKrMGfBkBo72iWKtw3cAzzW0,257
+goosebit/api/v1/rollouts/responses.py,sha256=grPcETWUSJrmVyQZs70jYhFjACsL-I_gPbg806BsauA,482
+goosebit/api/v1/rollouts/routes.py,sha256=wZki0Cz959gXYjQFjByU259TElubfhRs0RupYy8Xpl0,1683
+goosebit/api/v1/routes.py,sha256=g9vL0VOuFSdNG3FnK3y_03trwv4X2OLN9ustJeCgc58,272
+goosebit/api/v1/software/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/api/v1/software/requests.py,sha256=visd81BMeWDKJADcC10NBJDs7Z3xQC-5nod9z_WHiPg,101
+goosebit/api/v1/software/responses.py,sha256=pxhhqdjSkKOpF8KfJZuiRer0o4L3ydvb81RarEyAUlI,418
+goosebit/api/v1/software/routes.py,sha256=s89cBMB_IM4XR7CtftK9a6tPoTHoR6B9Et8KtuakfU0,2612
+goosebit/auth/__init__.py,sha256=REU94_KD2YmYYLNZdVhCIkNq8J7DOcVKyi_Grh5V2dc,4558
+goosebit/db/__init__.py,sha256=B8yfzkcjrb-qH-C6O_Uix4Y1ttcyJSxMBKwIFwNNo08,202
+goosebit/db/config.py,sha256=YCtF52lQ5bEVtKsrqkSzQpbKmCbD79O8Tz0RE4thV3c,220
+goosebit/db/migrations/models/0_20240830054046_init.py,sha256=EBig7b0-AOWt_AE10rQf_0ZrserjKTm0r53wYInK5Co,5526
+goosebit/db/models.py,sha256=P-mdryY9wbxGQkU3Dvy90fTgcKsksYJWEab3Vu9U2t4,4389
+goosebit/realtime/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/realtime/logs.py,sha256=JJ6bfVKzux9n3mXaUFoQhH2krGCpW7U1VzaloNmiORY,1223
+goosebit/realtime/routes.py,sha256=yLHrA-BHHU5cpUNvxAPVxWC3KcB9aUrV31HT_th24Ls,265
+goosebit/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+goosebit/schema/devices.py,sha256=jaZSP0yA_ef7mbbHvgQSeoO5MWehnNiHuTA_HnoYerc,2469
+goosebit/schema/rollouts.py,sha256=_43CtAMX1j6AhCRQkSBkoukvhRzGeOYQgkVxCx3wt4g,788
+goosebit/schema/software.py,sha256=xxwe6ix-dNa3Nt3FL4_mGSr45yXHzCxesjADREDsrWI,884
+goosebit/settings/__init__.py,sha256=UkJa_G_VJckNf16Em0zz8sXgEi5pzxHFvZ96oa9MC3k,360
+goosebit/settings/const.py,sha256=hOpeA9pGmbU4V4mqcfhpHV7cmEjf2GIenmzCSz2Jpj8,779
+goosebit/settings/schema.py,sha256=T6MntOkM6Pbf98dQHZoEVUADwKpeJqCrFDc40ufCiG4,2543
+goosebit/ui/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/ui/bff/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/ui/bff/devices/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/ui/bff/devices/requests.py,sha256=YbTUsyVLQZaUnn3dJ6AQe0mZl_H5aQC6QKCRxhCjGJc,286
+goosebit/ui/bff/devices/responses.py,sha256=ljXPzDX6CzWYguMOVYs1qBrlVyA0TqGn4kmxnkIgcAE,1431
+goosebit/ui/bff/devices/routes.py,sha256=H7ftSFz2d4BFNK7RV6a-m6m5eo6xv86xsDZweBj9k18,2680
+goosebit/ui/bff/download/__init__.py,sha256=kzt5TBA-bJmDZFXYPohggbMOW7GhklyflaRKZNC0yDY,42
+goosebit/ui/bff/download/routes.py,sha256=wdeXA-dGO4D9FxaUP6OnUSW4_2NZhi_VgIxMcSRL2x4,675
+goosebit/ui/bff/rollouts/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/ui/bff/rollouts/responses.py,sha256=wdQiMdgg6qY5pvu1aB3QsqZ1aQiOmBqFHk_ayoT9ByI,1403
+goosebit/ui/bff/rollouts/routes.py,sha256=Krr7ds_BRgezO-SUUBjXgxKpmWjijArJOLMkQLKLdGo,1408
+goosebit/ui/bff/routes.py,sha256=dq0fHXBiJfERzvUhvR4KVYCK3Ogf0Gb9wMSpzQanDac,323
+goosebit/ui/bff/software/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/ui/bff/software/responses.py,sha256=B85qsf5SgV4iuMvH5z3kv4IW0UDn4VkyPqg9z79BvNs,1404
+goosebit/ui/bff/software/routes.py,sha256=0BphAUN1wOGyBWnBuJufyje803lCRl10GWJTQWgt4BE,2610
+goosebit/ui/nav.py,sha256=ZdNGTST3bnRRT7P4vsS9LwlzB82H6SRshqSnQC35i_E,371
+goosebit/ui/routes.py,sha256=cc62_rEDjbniw0Fnsu7sZ13CNUuJ3z9z7F46urSUuBk,2151
+goosebit/ui/static/__init__.py,sha256=AsZiM3h9chQ_YaBbAD6TVFf0244Q9DetkDMl70q8swQ,135
+goosebit/ui/static/favicon.ico,sha256=MKAqEjW7F1-j2dmW4s08y4U0dFteIlU7rpLKakU0Lxk,4286
+goosebit/ui/static/favicon.svg,sha256=8zvM7o2Ob3YmTEV6Rj7rCTgSajvY6wIaAQAAjWwlDsw,8733
+goosebit/ui/static/js/devices.js,sha256=ZRAS1C_UzgQeB_MI8WjUGGaCPSUMOPPhgL-hns8B24I,11052
+goosebit/ui/static/js/index.js,sha256=ldsPX0PpGB1vkYEfMY05tYEgG6iCif3tx60aaAc3URY,5515
+goosebit/ui/static/js/login.js,sha256=9qlXki3udm5CmAO8UXUJe94Kc_-SJekdKjfH9TzJhgk,579
+goosebit/ui/static/js/logs.js,sha256=DgOWLKUvK-mM-oYRA0JJTIhtiCiegb5qCJ7pE9H2I3k,863
+goosebit/ui/static/js/rollouts.js,sha256=KQ_BaJn11VkLNBkIK7I_GLGpsPTjGg0ISEMfRszJtKQ,7174
+goosebit/ui/static/js/software.js,sha256=H9P4RjizC2EhL6Otjv4-iLnESdi3IvQYhWFvM4ddjaQ,8907
+goosebit/ui/static/js/util.js,sha256=D1EfZGCXlfmyDCXwae0XbHIsPckEbDNsqkCnrD_5D-o,3706
+goosebit/ui/static/svg/goosebit-logo.svg,sha256=8zvM7o2Ob3YmTEV6Rj7rCTgSajvY6wIaAQAAjWwlDsw,8733
+goosebit/ui/templates/__init__.py,sha256=xHCio6TnuNnYKLOZ3VhvbxyJPZ2ddzTSle_RmiuLrrA,378
+goosebit/ui/templates/devices.html.jinja,sha256=JROU5CInzjXlaiH2yxvCS1cepLXzU2O7TmiXUXJ2jes,3523
+goosebit/ui/templates/index.html.jinja,sha256=SDROkbhSRX6-pdET-yikfnrcfNKZR5zPhY2ByrSdAy4,907
+goosebit/ui/templates/login.html.jinja,sha256=eQX1ypZ5iJ2L4v4lw8VB7GKluUjUYmpoUyUy8jY98Og,3050
+goosebit/ui/templates/logs.html.jinja,sha256=JLHogVHWcP_Y321dd-gHexNqix-PFfGVpEKbNmzsMU8,1310
+goosebit/ui/templates/nav.html.jinja,sha256=cKS8SGxI_zP5oSElQ_dosmuvmf7sC9L0dHY2sZi1H-g,4241
+goosebit/ui/templates/rollouts.html.jinja,sha256=5FKm6EoBS-2Sk5L4cfWRxuoYZ-NT7ehff6Q_NapWp9k,4515
+goosebit/ui/templates/software.html.jinja,sha256=CTIeNkPMJMvtDVWbcKl_BjvtAFV3bskpCcNg-lCJIZM,7551
+goosebit/updater/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/updater/controller/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/updater/controller/routes.py,sha256=8CnLb-kDuO-yFeWdu4apIyctCf9OzvJ011Az3QDGemU,123
+goosebit/updater/controller/v1/__init__.py,sha256=4RRIzqC6KbCESIC9Vc6G4iAa28IWQH4KROTGd2S4AoI,41
+goosebit/updater/controller/v1/routes.py,sha256=cuRIS-K_Pf3ufiSq1e5Uur7eR06jbLO4mQ-Tl9UZy-E,7110
+goosebit/updater/controller/v1/schema.py,sha256=VomKoJYRWsbpkChWrq3SrjSVhPtkz6mrUcMrer94Tks,1200
+goosebit/updater/manager.py,sha256=WVqNQwr0ymgBcoBkyuGA_b_rKz6j9rAjn1fee-g1WRQ,11478
+goosebit/updater/routes.py,sha256=GfjbSdFYaw28B8b7hByOPN8BMIbaGvbz4CbG1jQCmP8,515
+goosebit/updates/__init__.py,sha256=MjoFNaMbCYJRNeXtg90AdFy5ott41Og1q01-D0XMgmc,4185
+goosebit/updates/swdesc.py,sha256=APfUMUkP8Tz2H1Ajk9FQeJfjJWARxoMGPSnJQiU0Xzc,2419
+goosebit-0.2.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+goosebit-0.2.1.dist-info/METADATA,sha256=V0osZhzcKX-lRPclYg1khVjMcPAfQDUeTotsCxFNO3E,5420
+goosebit-0.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+goosebit-0.2.1.dist-info/RECORD,,

goosebit/api/devices.py

@@ -1,136 +0,0 @@
-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/api/download.py

@@ -1,34 +0,0 @@
-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/api/firmware.py

@@ -1,57 +0,0 @@
-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/api/helper.py

@@ -1,30 +0,0 @@
-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/api/rollouts.py

@@ -1,87 +0,0 @@
-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/db.py

@@ -1,37 +0,0 @@
-from aerich import Command
-from tortoise import Tortoise, run_async
-
-from goosebit.models import Firmware
-from goosebit.settings import DB_MIGRATIONS_LOC, DB_URI
-
-TORTOISE_CONF = {
-    "connections": {"default": DB_URI},
-    "apps": {
-        "models": {
-            "models": ["goosebit.models", "aerich.models"],
-        },
-    },
-}
-
-
-async def init():
-    command = Command(tortoise_config=TORTOISE_CONF, location=DB_MIGRATIONS_LOC)
-    await Tortoise.init(config=TORTOISE_CONF)
-    if not DB_MIGRATIONS_LOC.exists():
-        await command.init_db(safe=True)
-    await command.init()
-    await command.migrate()
-    await command.upgrade(run_in_transaction=True)
-    await Tortoise.generate_schemas(safe=True)
-    for firmware in await Firmware.all():
-        if firmware.local and not firmware.path.exists():
-            # delete it
-            await firmware.delete()
-
-
-async def close():
-    await Tortoise.close_connections()
-
-
-if __name__ == "__main__":
-    run_async(init())

goosebit/permissions.py

@@ -1,75 +0,0 @@
-from enum import Enum
-from typing import TypeVar, cast
-
-T = TypeVar("T", bound="PermissionsBase")
-
-
-class PermissionsBase(str, Enum):
-    @classmethod
-    def full(cls) -> set[T]:
-        all_items = set[T]()
-        for permission in cls:
-            all_items.add(cast(T, permission))
-        return all_items
-
-    def __str__(self):
-        return self.value
-
-
-class FirmwarePermissions(PermissionsBase):
-    READ = "firmware.read"
-    WRITE = "firmware.write"
-    DELETE = "firmware.delete"
-
-
-class DevicePermissions(PermissionsBase):
-    READ = "device.read"
-    WRITE = "device.write"
-    DELETE = "device.delete"
-
-
-class RolloutPermissions(PermissionsBase):
-    READ = "rollout.read"
-    WRITE = "rollout.write"
-    DELETE = "rollout.delete"
-
-
-class HomePermissions(PermissionsBase):
-    READ = "home.read"
-
-
-class Permissions:
-    HOME = HomePermissions
-    FIRMWARE = FirmwarePermissions
-    DEVICE = DevicePermissions
-    ROLLOUT = RolloutPermissions
-
-    @classmethod
-    def full(cls) -> set[T]:
-        all_items = set()
-        for item in [cls.HOME, cls.FIRMWARE, cls.DEVICE, cls.ROLLOUT]:
-            all_items.update(item.full())
-        return all_items
-
-    @classmethod
-    def from_str(cls, permission: str) -> set[T]:
-        if permission == "*":
-            return cls.full()
-        area, action = permission.upper().split(".")
-        if area == "FIRMWARE":
-            return {FirmwarePermissions[action]}
-        if area == "DEVICE":
-            return {DevicePermissions[action]}
-        if area == "ROLLOUT":
-            return {RolloutPermissions[action]}
-        if area == "HOME":
-            return {HomePermissions[action]}
-
-
-ADMIN = Permissions.full()
-MONITORING = [
-    *Permissions.HOME.full(),
-    *Permissions.FIRMWARE.full(),
-    *Permissions.DEVICE.full(),
-]
-READONLY = [Permissions.HOME.READ]

goosebit/settings.py

@@ -1,64 +0,0 @@
-import secrets
-from dataclasses import dataclass
-from pathlib import Path
-
-import yaml
-from argon2 import PasswordHasher
-from joserfc.rfc7518.oct_key import OctKey
-
-from goosebit.permissions import Permissions
-
-BASE_DIR = Path(__file__).resolve().parent.parent
-TOKEN_SWU_DIR = BASE_DIR.joinpath("swugen")
-SWUPDATE_FILES_DIR = BASE_DIR.joinpath("swupdate")
-UPDATES_DIR = BASE_DIR.joinpath("updates")
-DB_MIGRATIONS_LOC = BASE_DIR.joinpath("migrations")
-
-SECRET = OctKey.import_key(secrets.token_hex(16))
-PWD_CXT = PasswordHasher()
-
-with open(BASE_DIR.joinpath("settings.yaml"), "r") as f:
-    config = yaml.safe_load(f.read())
-
-LOGGING = config.get("logging", {})
-
-TENANT = config.get("tenant", "DEFAULT")
-
-POLL_TIME = config.get("poll_time_default", "00:01:00")
-POLL_TIME_UPDATING = config.get("poll_time_updating", "00:00:05")
-POLL_TIME_REGISTRATION = config.get("poll_time_registration", "00:00:10")
-
-DB_LOC = BASE_DIR.joinpath(config.get("db_location", "db.sqlite3"))
-DB_URI = f"sqlite:///{DB_LOC}"
-
-
-@dataclass
-class User:
-    username: str
-    hashed_pwd: str
-    permissions: set
-
-    def get_json_permissions(self):
-        return [str(p) for p in self.permissions]
-
-
-users: dict[str, User] = {}
-
-
-def add_user(u: User):
-    users[u.username] = u
-
-
-for user in config.get("users", []):
-    permissions = set()
-    for p in user["permissions"]:
-        permissions.update(Permissions.from_str(p))
-    add_user(
-        User(
-            username=user["email"],
-            hashed_pwd=PWD_CXT.hash(user["password"]),
-            permissions=permissions,
-        )
-    )
-
-USERS = users

goosebit/telemetry/prometheus.py

@@ -1,10 +0,0 @@
-from opentelemetry.exporter.prometheus import PrometheusMetricReader
-from prometheus_client import start_http_server
-
-from goosebit import settings
-
-PROMETHEUS_PORT = settings.config.get("metrics", {}).get("prometheus", {}).get("port", 9090)
-
-# separate file to enable it as a feature later.
-reader = PrometheusMetricReader()
-start_http_server(port=PROMETHEUS_PORT, addr="0.0.0.0")