I lost track of what I was doing. But we dont need the license.json anymore.

src/container_managment.py

@@ -1,8 +1,8 @@
 import docker
 from game_tables import GameTable
 from key_tables import KeyTable
-import shutil
 import os
+from flask import current_app
 
 
 def build_container_routing_labels(prefix: str, strip_prefix=True):
@@ -37,7 +37,7 @@ def stop_container(docker_id):
         return False
 
 
-def start_foundry_container(table: GameTable, key: KeyTable, version=12):
+def start_foundry_container(table: GameTable, key: KeyTable):
     client = docker.from_env()
     container = None
 
@@ -51,23 +51,21 @@ def start_foundry_container(table: GameTable, key: KeyTable, version=12):
         container.start()
 
     else:
-        image = "felddy/foundryvtt:{version}".format(version=version)
+        image = "felddy/foundryvtt:{version}".format(version=table.version)
         labels = build_container_routing_labels(table.game_table_link, False)
-        os.makedirs("/data/" + table.game_table_link + "/Config", exist_ok=True)
-        shutil.copyfile(
-            src="/data/keys/" + key.key_file,
-            dst="/data/" + table.game_table_link + "/Config/license.json",
-        )
         volumes = {
-            "/home/cow/Projects/dockertesting/data/{prefix}".format(
+            "{data_bind}/{prefix}".format(
-                prefix=table.game_table_link
+                data_bind=os.environ.get("FOUNDRY_DATA_BIND"),
+                prefix=table.game_table_link,
             ): {"bind": "/data", "mode": "rw"},
-            "/home/cow/Projects/dockertesting/data/container_cache": {
+            "{data_bind}/container_cache".format(
-                "bind": "/data/container_cache"
+                data_bind=os.environ.get("FOUNDRY_DATA_BIND")
-            },
+            ): {"bind": "/data/container_cache"},
         }
         environment = [
-            "FOUNDRY_ROUTE_PREFIX={prefix}".format(prefix=table.game_table_link)
+            "FOUNDRY_ROUTE_PREFIX={prefix}".format(prefix=table.game_table_link),
+            "FOUNDRY_TELEMETRY=FALSE",
+            "FOUNDRY_LICENSE_KEY={key_value}".format(key_value=key.key),
         ]
 
         ports = {"30000": str(30000 + table.game_table_id)}

src/database.py

@@ -15,6 +15,7 @@ CREATE TABLE IF NOT EXISTS "game_tables" (
 	"game_table_id" INTEGER NOT NULL UNIQUE,
 	"game_table_name" TEXT UNIQUE,
 	"game_table_link" TEXT UNIQUE,
+    "version" INTEGER
 	"active" INTEGER DEFAULT 0,
 	"game_key" TEXT,
 	"docker_id" TEXT,

src/game_tables.py

@@ -2,15 +2,18 @@ from sqlite3 import Connection, Cursor
 from database import SmartCursor
 import random
 
+
 class GameTableException(Exception):
     def __init__(self, message):
         super().__init__(self, message)
 
+
 class GameTable:
     _game_table_id: int
     _game_table_name: str
     _game_table_link: str
     _active: bool
+    _version: int
     _docker_id: str
     _created: bool
     _updated: bool
@@ -22,15 +25,17 @@ class GameTable:
         game_table_name: str,
         game_table_link: str,
         active: bool,
+        version: int,
         docker_id: int,
         created: bool = False,
         updated: bool = False,
-        delete: bool = False
+        delete: bool = False,
     ):
         self._game_table_id = game_table_id
         self._game_table_name = game_table_name
         self._game_table_link = game_table_link
         self._active = active
+        self._version = version
         self._docker_id = docker_id
         self._created = created
         self._updated = updated
@@ -41,6 +46,7 @@ class GameTable:
             "id": self._game_table_id,
             "table_name": self._game_table_name,
             "table_link": self._game_table_link,
+            "version": self._version,
             "active": self._active,
         }
 
@@ -50,12 +56,13 @@ class GameTable:
                 self._game_table_id = random.randint(1, 999999999)
             cursor.execute(
                 """INSERT INTO game_tables
-                   (game_table_id, game_table_name, game_table_link, active, docker_id)
+                   (game_table_id, game_table_name, game_table_link, version, active, docker_id)
-                   VALUES (?, ?, ?, ?, ?)""",
+                   VALUES (?, ?, ?, ?, ?, ?)""",
                 (
                     self._game_table_id,
                     self._game_table_name,
                     self._game_table_link,
+                    self._version,
                     self._active,
                     self._docker_id,
                 ),
@@ -66,11 +73,12 @@ class GameTable:
         if not self._updated:
             cursor.execute(
                 """UPDATE game_tables
-                   SET game_table_name = ?, game_table_link = ?, active = ?, docker_id = ?
+                   SET game_table_name = ?, game_table_link = ?, version = ?, active = ?, docker_id = ?
                    WHERE game_table_id = ?""",
                 (
                     self._game_table_name,
                     self._game_table_link,
+                    self._version,
                     self._active,
                     self._docker_id,
                     self._game_table_id,
@@ -79,7 +87,10 @@ class GameTable:
             self._updated = True
             return
         if self._delete:
-            cursor.execute("DELETE FROM game_tables WHERE game_table_id = ?", (self._game_table_id,))
+            cursor.execute(
+                "DELETE FROM game_tables WHERE game_table_id = ?",
+                (self._game_table_id,),
+            )
             self._created = False
             self._updated = True
             self._delete = False
@@ -118,6 +129,15 @@ class GameTable:
         self._updated = False
         self._game_table_link = game_table_link
 
+    @property
+    def version(self):
+        return self._version
+
+    @version.setter
+    def version(self, version: int):
+        self._updated = False
+        self._version = version
+
     @property
     def active(self):
         return self._active
@@ -146,7 +166,7 @@ class GameService:
     def read_by_id(self, game_table_id, cursor=None):
         with SmartCursor(cursor, self.connection) as smartCursor:
             rows = smartCursor.execute(
-                """SELECT game_table_id, game_table_name, game_table_link, active, docker_id
+                """SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id
                    FROM game_tables
                    WHERE game_table_id = ?""",
                 (game_table_id,),
@@ -155,24 +175,54 @@ class GameService:
             if len(rows) == 0:
                 return None
 
-            return GameTable(rows[0], rows[1], rows[2], rows[3], rows[4], True, True, False)
+            return GameTable(
+                game_table_id=rows[0],
+                game_table_name=rows[1],
+                game_table_link=rows[2],
+                active=rows[3],
+                version=rows[4],
+                docker_id=rows[5],
+                created=True,
+                updated=True,
+                delete=False,
+            )
 
     def read_all(self, cursor=None):
         with SmartCursor(cursor, self.connection) as smartCursor:
             rows = smartCursor.execute(
-                "SELECT game_table_id, game_table_name, game_table_link, active, docker_id FROM game_tables"
+                "SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id FROM game_tables"
             ).fetchall()
         return [
-            GameTable(row[0], row[1], row[2], row[3], row[4], True, True, False)
+            GameTable(
+                game_table_id=row[0],
+                game_table_name=row[1],
+                game_table_link=row[2],
+                active=row[3],
+                version=row[4],
+                docker_id=row[5],
+                created=True,
+                updated=True,
+                delete=False,
+            )
             for row in rows
         ]
 
     def read_active(self, cursor=None):
         with SmartCursor(cursor, self.connection) as smartCursor:
             rows = smartCursor.execute(
-                "SELECT game_table_id, game_table_name, game_table_link, active, docker_id FROM game_tables WHERE active != 0"
+                "SELECT game_table_id, game_table_name, game_table_link, active, version, docker_id FROM game_tables WHERE active != 0"
             ).fetchall()
         return [
-            GameTable(row[0], row[1], row[2], row[3], row[4], True, True, False)
+            GameTable(
+                game_table_id=row[0],
+                game_table_name=row[1],
+                game_table_link=row[2],
+                active=row[3],
+                version=row[4],
+                docker_id=row[5],
+                created=True,
+                updated=True,
+                delete=False,
+            )
             for row in rows
         ]

src/tables.py

@@ -10,13 +10,12 @@ tables = Blueprint("tables_api", __name__)
 
 @tables.route("/tables", methods=["POST"])
 def create_table():
-    current_app.logger.info(request.get_json())
     db = get_db()
     with SmartCursor(connection=db) as smartCursor:
         table = GameTable(
-            game_table_id=random.randrange(1, 100000),
             game_table_name=request.get_json()["table_name"],
             game_table_link=request.get_json()["table_link"],
+            version=request.get_json()["version"],
             active=False,
             docker_id=None,
         )
@@ -34,7 +33,16 @@ def get_table(table_id):
 
 @tables.route("/tables/<int:table_id>", methods=["POST"])
 def update_table(table_id):
-    return
+    db = get_db()
+    gameService = GameService(db)
+    table = gameService.read_by_id(table_id)
+    table.game_table_name = request.get_json()["table_name"]
+    table.game_table_link = request.get_json()["table_link"]
+    table.version = request.get_json()["version"]
+    with SmartCursor(connection=db) as smartCursor:
+        table.commit(smartCursor)
+    db.commit()
+    return table.toJson(), 200
 
 
 @tables.route("tables/<table_id>", methods=["DELETE"])
@@ -90,10 +98,13 @@ def activate_table(table_id):
     if len(keys) == 0:
         return "No more keys", 400
 
-    keys[0].reserve(table.game_table_id)
+    key = keys[0]
+    current_app.logger.info(table.game_table_id)
+    current_app.logger.info(table.docker_id)
+    key.reserve(table.game_table_id)
     table.active = True
-    table.docker_id = container_managment.start_foundry_container(table, keys[0])
+    table.docker_id = container_managment.start_foundry_container(table, key)
-    keys[0].commit(cursor)
+    key.commit(cursor)
     table.commit(cursor)
     cursor.close()
     db.commit()