Initial work on release manager

footron_controller/api.py

@@ -1,12 +1,16 @@
 import asyncio
 import atexit
 import dataclasses
+import hashlib
+import tarfile
+from tempfile import TemporaryFile
 from typing import Optional
 
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
+from .releases import ReleaseManager
 from .placard import PlacardData
 from .experiences import BaseExperience
 from .collection import Collection
@@ -22,6 +26,7 @@
     allow_headers=["*"],
 )
 
+_releases: ReleaseManager
 _controller: Controller
 
 
@@ -34,6 +39,10 @@ class UpdateCurrentExperienceBody(BaseModel):
     end_time: Optional[int]
 
 
+class SetExperienceReleaseBody(BaseModel):
+    hash: str
+
+
 def experience_response(experience: BaseExperience):
     data = {
         "id": experience.id,
@@ -141,8 +150,43 @@ async def update_placard(body: PlacardData):
 
 @fastapi_app.on_event("startup")
 def on_startup():
-    global _controller
-    _controller = Controller()
+    global _releases, _controller
+    _releases = ReleaseManager()
+    _controller = Controller(_releases)
+
+
+@fastapi_app.get("/releases")
+def releases():
+    return _releases.data
+
+
+@fastapi_app.post("/releases/{id}")
+async def add_release(id: str, file: UploadFile = File(...)):
+    # TODO: Is this too slow? Will it freeze the controller?
+    uncompressed_file = tarfile.open(fileobj=file.file, mode="r:gz")
+    tar_fileobj = uncompressed_file.fileobj
+
+    hash = hashlib.sha256()
+    while True:
+        chunk = tar_fileobj.read(4096)
+        if not chunk:
+            break
+        hash.update(chunk)
+
+    # Produces a hash different than sha256sum on the same file locally--this might not
+    # be a problem but we should be aware that it could be. Might be an encoding thing,
+    # not sure.
+    hash = bytes.hex(hash.digest())
+
+    uncompressed_file.extractall(_releases.create_release(id, hash))
+
+    return {"hash": hash}
+
+
+@fastapi_app.put("/releases/{id}")
+async def set_release(id: str, body: SetExperienceReleaseBody):
+    _releases.set_release(id, body.hash)
+    return {"status": "ok"}
 
 
 @atexit.register

footron_controller/controller.py

@@ -4,6 +4,7 @@
 
 from .experiences import load_experiences_fs, BaseExperience
 from .placard import PlacardApi, PlacardData
+from .releases import ReleaseManager
 from .collection import load_collections_from_fs, Collection
 
 
@@ -14,12 +15,14 @@ class Controller:
     end_time: Optional[int]
     last_update: datetime.datetime
     placard: PlacardApi
+    releases: ReleaseManager
 
-    def __init__(self):
+    def __init__(self, releases: ReleaseManager):
         self.current_experience = None
         self.end_time = None
 
         self.placard = PlacardApi()
+        self.releases = releases
 
         self.load_from_fs()
 
@@ -29,7 +32,9 @@ def load_from_fs(self):
         self.last_update = datetime.datetime.now()
 
     def load_experiences(self):
-        self.experiences = {app.id: app for app in load_experiences_fs()}
+        self.experiences = {
+            app.id: app for app in load_experiences_fs(self.releases.path)
+        }
 
     def load_collections(self):
         self.collections = {

footron_controller/releases.py

@@ -0,0 +1,107 @@
+import json
+from datetime import datetime
+from typing import Dict, Optional
+
+import pydantic
+import pydantic.json
+from pydantic import BaseModel
+
+from .constants import BASE_DATA_PATH, EXPERIENCES_PATH
+
+_RELEASES_DIR_NAME = "releases"
+_DATA_FILENAME = "data.json"
+
+
+class _Release(BaseModel):
+    hash: str
+    created: datetime
+
+
+class _ExperienceReleases(BaseModel):
+    current: Optional[str]
+    releases: Dict[str, _Release]
+
+
+class ReleaseManager:
+    _release_data: Dict[str, _ExperienceReleases]
+
+    # TODO: Figure out how we limit # of older releases kept per app--maybe by size?
+    def __init__(self):
+        self._releases_path = BASE_DATA_PATH / _RELEASES_DIR_NAME
+        self._linked_path = EXPERIENCES_PATH / "apps"
+        self._data_path = self._releases_path / _DATA_FILENAME
+
+        self._load_releases_data()
+
+    @property
+    def path(self):
+        return self._linked_path
+
+    @property
+    def data(self):
+        return self._release_data
+
+    def _load_releases_data(self):
+        if not self._data_path.exists():
+            self._release_data = {}
+            return
+
+        with open(self._data_path) as data_file:
+            self._release_data = {
+                id: _ExperienceReleases.parse_obj(data)
+                for id, data in json.load(data_file).items()
+            }
+
+    def _save_release_data(self):
+        with open(self._data_path, "w") as data_file:
+            json.dump(
+                {id: data for id, data in self._release_data.items()},
+                data_file,
+                default=pydantic.json.pydantic_encoder,
+            )
+
+    def create_release(self, id: str, hash: str):
+        # TODO: This is probably the right place to clean up old releases
+        if id not in self._release_data:
+            self._release_data[id] = _ExperienceReleases(current=None, releases={})
+
+        # TODO: We don't check if there's an existing release here--might be a good
+        #  idea?
+        self._release_data[id].releases[hash] = _Release(
+            hash=hash, created=datetime.now()
+        )
+        self._save_release_data()
+
+        release_path = self.path_for_release(id, hash)
+        if not release_path.exists():
+            release_path.mkdir(parents=True)
+
+        return release_path
+
+    def set_release(self, id: str, hash: str):
+        if not self.release_exists(id, hash):
+            raise FileNotFoundError(f"Release path does not exist: {id}/{hash}")
+
+        if not self._linked_path.exists():
+            self._linked_path.mkdir(parents=True)
+
+        linked_path = self._linked_path / id
+        if linked_path.exists():
+            linked_path.unlink()
+
+        linked_path.symlink_to(
+            self.path_for_release(id, hash), target_is_directory=True
+        )
+
+        self._release_data[id].current = hash
+        self._save_release_data()
+
+    def release_exists(self, id, hash) -> bool:
+        return (
+            id in self._release_data
+            and hash in self._release_data[id].releases
+            and self.path_for_release(id, hash).exists()
+        )
+
+    def path_for_release(self, id, hash):
+        return self._releases_path / id / hash

setup.cfg

@@ -14,4 +14,5 @@ install_requires =
     fastapi
     uvicorn[standard]
     aiohttp
+    python-multipart
     docker