minor updates and fixes

code written so smooth, that butter takes notes

uploader-service/app.py

@@ -0,0 +1,207 @@
+import os
+import uuid
+import sqlite3
+import docker
+import requests
+import threading
+from flask import Flask, request, jsonify, render_template
+import json
+import time
+import shutil
+import dotenv
+dotenv.load_dotenv()
+
+app = Flask(__name__)
+DATABASE = "machines.db"
+FLY_APP = "snaketest"
+FLY_REGISTRY = os.getenv("FLY_REGISTRY")
+FLY_API_URL = os.getenv("FLY_API_URL")
+FLY_API_TOKEN = os.getenv("FLY_API_TOKEN")
+
+# Ensure database exists
+def init_db():
+    with sqlite3.connect(DATABASE) as conn:
+        conn.execute('''CREATE TABLE IF NOT EXISTS machines (
+                            name TEXT PRIMARY KEY,
+                            pid INTEGER,
+                            ipv6 TEXT
+                            
+                        )''')
+
+ready_to_deploy = False
+
+
+@app.route("/upload", methods=["POST"])
+def upload_file():
+    if "file" not in request.files:
+        return jsonify({"error": "No IPython Notebook file uploaded"}), 400
+    
+    file = request.files["file"]
+    json_file = request.files.get("json_file")
+    
+    name = request.form.get("name")
+    if not name:
+        return jsonify({"error": "Name is required"}), 400
+    # check if name already taken
+    with sqlite3.connect(DATABASE) as conn:
+        cur = conn.cursor()
+        cur.execute("SELECT * FROM machines WHERE name = ?", (name,))
+        if cur.fetchone():
+            return jsonify({"error": "Name already taken"}), 409
+    
+    pid = request.form.get("pid")
+    
+    unique_id = str(uuid.uuid4())
+    
+    upload_dir = os.path.join("uploads", unique_id)
+    os.makedirs(upload_dir, exist_ok=True)
+    
+    file_path = os.path.join(upload_dir, "notebook.ipynb")
+    file.save(file_path)
+    
+    if json_file:
+        json_path = os.path.join(upload_dir, json_file.filename)
+        json_file.save(json_path)
+    
+    os.system(f'cp Dockerfile {upload_dir}/Dockerfile') 
+    
+    
+    # threading.Thread(target=build_and_push_docker_image, args=(name, pid, unique_id, upload_dir)).start()
+    ipv6 = build_and_push_docker_image(name, pid, unique_id, upload_dir)
+
+    if ipv6 is None:
+        return jsonify({"error": "Failed to deploy this snake"}), 500
+    
+    print("ipv6", ipv6)
+    return jsonify({"message": "File uploaded", "ipv6": ipv6}), 200
+
+def build_and_push_docker_image(name, pid, unique_id, upload_dir):
+    print("Building and pushing docker image")
+    client = docker.from_env()
+    image_tag = f"{FLY_REGISTRY}:{unique_id}"
+    
+   
+    client.images.build(path=upload_dir, tag=image_tag, dockerfile="Dockerfile")
+    
+    
+    client.images.push(image_tag)
+    
+    print("Docker image built and pushed")
+    global ready_to_deploy 
+    ready_to_deploy = True
+    print("about to deploy", ready_to_deploy)
+    ipv6 = deploy_machine(name, pid, image_tag)
+    
+    # Cleanup junk
+    # os.system(f"rm -rf {upload_dir}")
+    print("upload", upload_dir)
+    shutil.rmtree(upload_dir)
+    print("Cleanup done")
+    return ipv6
+
+def deploy_machine(name, pid, image_tag):
+    print("Deploying machine")
+    print("ready to deploy", ready_to_deploy)
+    while not ready_to_deploy:
+        print("sleeping")
+        time.sleep(2)
+    headers = {
+        "Authorization": f"Bearer {FLY_API_TOKEN}",
+        "Content-Type": "application/json"
+        }
+    data = {
+        "config": {
+            "env": {
+                "FLY_PROCESS_GROUP": "app"
+            },
+            "init": {},
+            "guest": {
+                "cpu_kind": "shared",
+                "cpus": 1,
+                "memory_mb": 512
+            },
+            "metadata": {
+                "fly_flyctl_version": "0.3.87",
+                "fly_platform_version": "v2",
+                "fly_process_group": "app",
+                "fly_release_id": "7pGPxgX11jYG2T94NqvJGYYxB",
+                "fly_release_version": "1"
+            },
+            "services": [
+                {
+                    "protocol": "tcp",
+                    "internal_port": 8000,
+                    "force_instance_key": None
+                }
+            ],
+            "image": f"{image_tag}",
+            "restart": {
+                "policy": "on-failure",
+                "max_retries": 10
+            }
+        }
+    }
+    # data = json.dumps(data)
+    response = requests.post(FLY_API_URL, json=data, headers=headers)
+    print(response.json())
+    print(response.status_code)
+    if response.status_code == 200:
+        machine_data = response.json()
+        # fly_machine_id = machine_data["id"]
+        ipv6 = machine_data["private_ip"]
+        print("ipv6", ipv6)
+        with sqlite3.connect(DATABASE) as conn:
+            conn.execute("INSERT INTO machines (name, pid, ipv6) VALUES (?, ?, ?)", 
+                         (name, pid, ipv6))
+        print("Machine deployed")
+        print(f"Machine deployed with Ip: {ipv6}")
+        return ipv6
+    else:
+        print("Failed to deploy machine.")
+        return None
+        
+
+
+
+def upload_to_battlesnake():
+    pass
+
+
+
+def get_machine_info(machine_id):
+    with sqlite3.connect(DATABASE) as conn:
+        cur = conn.cursor()
+        cur.execute("SELECT pid, ipv6 FROM machines WHERE name = ?", (name))
+        row = cur.fetchone()
+        if row:
+            return {"ipv6": row[0], "status": row[1]}
+    return None
+
+
+
+
+
+
+@app.route("/mock", methods=["POST"])
+def mock():
+    time.sleep(5)
+    return jsonify({"message": "File uploaded", "ipv6": "ff:00:00:00:00::ff"}), 200
+
+@app.route("/uploader")
+def uploader():
+    return render_template("uploader.html")
+
+
+@app.route("/status/<machine_id>", methods=["GET"])
+def status(machine_id):
+    result = get_machine_info(machine_id)
+    if result is None:
+        return jsonify({"error": "Machine not found"}), 404
+    return jsonify(result), 200
+
+    
+    # return jsonify({"step": get_step(machine_id), **get_machine_status(machine_id)})
+
+if __name__ == "__main__":
+    init_db()
+    app.run(debug=True, port=5000, host='0.0.0.0')