Update routers/deploy.py

routers/deploy.py

@@ -1,194 +1,121 @@
-# Standard library imports
-import os
+from fastapi import APIRouter, HTTPException, UploadFile, Form
+from fastapi.responses import JSONResponse
+import docker
 import uuid
+import zipfile
+import os
 import time
-import zipfile # Still imported, but primarily for handling potential old zip logic or error messages
-
-# Third-party library imports
-import docker # For interacting with Docker daemon
-import hmac # For validating GitHub webhook signatures (important for security)
-import hashlib # For hashing in webhook signature validation
-from pyngrok import ngrok # For creating public URLs (ensure ngrok is configured)
-from fastapi import APIRouter, HTTPException, UploadFile, Form, Request, BackgroundTasks # Added Request and BackgroundTasks
-from fastapi.responses import JSONResponse
+from pyngrok import ngrok
 
-# Initialize FastAPI router
 router = APIRouter()
 
-deployed_projects = {}
-
-# --- Helper Functions ---
-
-# Function to recursively find a file (case-insensitive) within a directory
-def _find_file_in_project(filename: str, root_dir: str) -> str | None:
-    """
-    Searches for a file (case-insensitive) within the given root directory and its subdirectories.
-    Returns the absolute path to the file if found, otherwise None.
-    """
-    filename_lower = filename.lower()
-    for dirpath, _, files in os.walk(root_dir):
-        for file in files:
-            if file.lower() == filename_lower:
-                return os.path.join(dirpath, file)
-    return None
-
-# Function to build and deploy a Docker container from a project path
-
-# --- API Endpoints ---
-
 @router.post("/project")
-async def deploy_from_git(repo_url: str = Form(...), app_name: str = Form(...)):
-    """
-    Deploys a FastAPI/Flask application from a specified Git repository.
-    The repository must contain a main.py, requirements.txt, and Dockerfile.
-    """
-    # Basic validation for the Git repository URL format
-    if not repo_url.startswith(("http://", "https://", "git@", "ssh://")):
-        raise HTTPException(status_code=400, detail="Invalid Git repository URL format. Must be HTTP(S) or SSH.")
-
-    # Generate a unique ID for this project
-    project_id = str(uuid.uuid4())
+async def deploy_code(file: UploadFile, app_name: str = Form(...)):
+    if not file.filename.endswith(".zip"):
+        raise HTTPException(status_code=400, detail="Only .zip files are supported")
     
-    # Define project directories
-    base_dir = os.path.dirname(os.path.abspath(__file__)) # This is where 'router.py' is
-    projects_dir = os.path.abspath(os.path.join(base_dir, "..", "projects")) # Parent directory's 'projects' folder
-    os.makedirs(projects_dir, exist_ok=True) # Ensure the base projects directory exists
+    # Create unique project directory
+    project_id = str(uuid.uuid4())
+    base_dir = os.path.dirname(os.path.abspath(__file__))  # /router/
+    projects_dir = os.path.abspath(os.path.join(base_dir, "..", "projects"))
+    os.makedirs(projects_dir, exist_ok=True)
 
     project_path = os.path.join(projects_dir, project_id)
-    os.makedirs(project_path, exist_ok=True) # Create a unique directory for this project
+    os.makedirs(project_path, exist_ok=True)
+
+    # Save uploaded zip
+    zip_path = os.path.join(project_path, file.filename)
+    with open(zip_path, "wb") as f:
+        f.write(await file.read())
 
+    # Extract zip contents
     try:
-        # Step 1: Clone the Git repository
-        print(f"Cloning repository {repo_url} into {project_path}")
-        git.Repo.clone_from(repo_url, project_path)
-        print("Repository cloned successfully.")
-
-    except git.exc.GitCommandError as e:
-        print(f"Git clone failed: {e.stderr.decode()}")
-        # Clean up the partially created project directory if cloning fails
-        if os.path.exists(project_path):
-            import shutil
-            shutil.rmtree(project_path)
-        raise HTTPException(status_code=400, detail=f"Failed to clone repository: {e.stderr.decode()}")
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(project_path)
     except Exception as e:
-        print(f"Unexpected error during git clone: {e}")
-        if os.path.exists(project_path):
-            import shutil
-            shutil.rmtree(project_path)
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred during repository cloning: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Invalid zip file: {str(e)}")
+
+    # Debug: print all extracted files
+    print(f"[DEBUG] Extracted files in: {project_path}")
+    for dirpath, _, files in os.walk(project_path):
+        for fname in files:
+            print(" -", os.path.join(dirpath, fname))
 
-    # Step 2: Validate required project files (main.py, requirements.txt, Dockerfile)
-    main_py_path = _find_file_in_project("main.py", project_path)
-    requirements_txt_path = _find_file_in_project("requirements.txt", project_path)
-    dockerfile_path = _find_file_in_project("Dockerfile", project_path)
+    # Case-insensitive recursive search for file
+    def find_file(filename, root):
+        filename = filename.lower()
+        for dirpath, _, files in os.walk(root):
+            for file in files:
+                if file.lower() == filename:
+                    return os.path.join(dirpath, file)
+        return None
+
+
+    main_py = find_file("main.py", project_path)
+    requirements_txt = find_file("requirements.txt", project_path)
+    dockerfile = find_file("Dockerfile", project_path)  # lowercase f
 
     missing_files = []
-    if not main_py_path:
+    if not main_py:
         missing_files.append("main.py")
-    if not requirements_txt_path:
+    if not requirements_txt:
         missing_files.append("requirements.txt")
-    if not dockerfile_path:
+    if not dockerfile:
         missing_files.append("Dockerfile")
 
     if missing_files:
-        # Clean up the project directory if essential files are missing
-        if os.path.exists(project_path):
-            import shutil
-            shutil.rmtree(project_path)
         raise HTTPException(
             status_code=400,
-            detail=f"The cloned repository is missing required file(s): {', '.join(missing_files)} (case-insensitive search)."
+            detail=f"Zip is missing required file(s): {', '.join(missing_files)} (case-insensitive)"
         )
 
-    # Ensure Dockerfile is at the root of the project_path for Docker build context
-    if os.path.dirname(dockerfile_path) != project_path:
-        print(f"[DEBUG] Moving Dockerfile from {dockerfile_path} to project root: {project_path}")
-        target_dockerfile_path = os.path.join(project_path, "Dockerfile")
-        os.replace(dockerfile_path, target_dockerfile_path)
-        dockerfile_path = target_dockerfile_path # Update the path to reference the new location
-
-    # Step 3: Store initial project details in global state (or database)
-    deployed_projects[project_id] = {
-        "app_name": app_name,
-        "repo_url": repo_url,
-        "project_path": project_path,
-        "status": "building", # Set initial status
-        "container_name": None, # Will be set by _build_and_deploy
-        "public_url": None, # Will be set by _build_and_deploy
-        "ngrok_tunnel": None # Will be set by _build_and_deploy
-    }
-    print(f"Project {project_id} initialized for deployment.")
-
-    # Step 4: Trigger the build and deploy process
+    # Move Dockerfile to root if needed
+    if os.path.dirname(dockerfile) != project_path:
+        print(f"[DEBUG] Moving Dockerfile from {dockerfile} to project root")
+        target_path = os.path.join(project_path, "Dockerfile")
+        os.replace(dockerfile, target_path)
+        dockerfile = target_path
+
+    # Build and run Docker container
+    image_name = f"{app_name.lower()}_{project_id[:8]}"
+    container_name = image_name
+
     try:
-        public_url, container_name = await _build_and_deploy(project_id, project_path, app_name)
+        docker_client = docker.from_env()
+        for c in docker_client.containers.list(all=True):
+            if c.status in ["created", "exited"]:
+                print(f"Removing leftover container {c.name} ({c.id})")
+                c.remove(force=True)
+                
+        image, _ = docker_client.images.build(path=project_path, tag=image_name)
+
+        container = docker_client.containers.run(
+            image=image_name,
+            ports={"8080/tcp": None},
+            name=container_name,
+            detach=True,
+            mem_limit="512m",
+            nano_cpus=1_000_000_000,
+            read_only=True,
+            tmpfs={"/tmp": ""},
+            user="1001:1001"
+        )
+
+        time.sleep(2)
+
+        port_info = docker_client.api.port(container.id, 8080)
+        if not port_info:
+            raise Exception("Port 8080 not exposed by container")
+        port = port_info[0]['HostPort']
+
+        tunnel = ngrok.connect(port, bind_tls=True)
+        public_url = tunnel.public_url
+
         return JSONResponse({
             "project_id": project_id,
             "container_name": container_name,
-            "preview_url": public_url,
-            "message": "Deployment initiated from Git repository. Check logs for status."
-        }, status_code=202) # Use 202 Accepted, as deployment happens in background
-    except HTTPException as e:
-        # If _build_and_deploy raises a specific HTTPException, re-raise it
-        if project_id in deployed_projects:
-            deployed_projects[project_id]["status"] = "failed"
-        raise e
-    except Exception as e:
-        # Catch any other unexpected errors during the build/deploy phase
-        if project_id in deployed_projects:
-            deployed_projects[project_id]["status"] = "failed"
-        print(f"Error during initial _build_and_deploy for project {project_id}: {e}")
-        raise HTTPException(status_code=500, detail=f"Initial deployment failed unexpectedly: {str(e)}")
-
-
-# --- Cleanup Endpoint (Optional, for manual testing/management) ---
-@router.post("/project/delete/{project_id}")
-async def delete_project(project_id: str):
-    """
-    Deletes a deployed project, its Docker container, ngrok tunnel, and local files.
-    """
-    if project_id not in deployed_projects:
-        raise HTTPException(status_code=404, detail=f"Project with ID {project_id} not found.")
-
-    project_data = deployed_projects[project_id]
-    
-    # Stop and remove Docker container
-    docker_client = docker.from_env()
-    container_name = project_data.get("container_name")
-    if container_name:
-        try:
-            container = docker_client.containers.get(container_name)
-            container.stop(timeout=5)
-            container.remove(force=True)
-            print(f"Container {container_name} for project {project_id} removed.")
-        except docker.errors.NotFound:
-            print(f"Container {container_name} not found, already removed?")
-        except Exception as e:
-            print(f"Error removing container {container_name}: {e}")
-            # Do not raise HTTPException, try to continue cleanup
-
-    # Disconnect ngrok tunnel
-    ngrok_tunnel = project_data.get("ngrok_tunnel")
-    if ngrok_tunnel:
-        try:
-            ngrok_tunnel.disconnect()
-            print(f"Ngrok tunnel for project {project_id} disconnected.")
-        except Exception as e:
-            print(f"Error disconnecting ngrok tunnel for project {project_id}: {e}")
-    
-    # Remove local project directory
-    project_path = project_data.get("project_path")
-    if project_path and os.path.exists(project_path):
-        try:
-            import shutil
-            shutil.rmtree(project_path)
-            print(f"Project directory {project_path} removed.")
-        except Exception as e:
-            print(f"Error removing project directory {project_path}: {e}")
-
-    # Remove from global state
-    del deployed_projects[project_id]
-    print(f"Project {project_id} removed from deployed_projects.")
-
-    return JSONResponse({"message": f"Project {project_id} and associated resources deleted."})
+            "preview_url": public_url
+        })
 
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)