Upload app.py

app.py

@@ -1,127 +1,65 @@
-from fastapi import FastAPI, HTTPException
-import subprocess
-import os
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI()
-
-def run_docker_compose(command):
-    """Run a docker-compose command and return the result"""
-    try:
-        result = subprocess.run(
-            f"docker-compose {command}",
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        if result.returncode != 0:
-            logger.error(f"Docker compose {command} failed: {result.stderr}")
-            raise Exception(result.stderr)
-        return result.stdout
-    except Exception as e:
-        logger.error(f"Error running docker-compose {command}: {e}")
-        raise
-
-@app.on_event("startup")
-async def startup_event():
-    try:
-        logger.info("Starting Docker Compose stack...")
-        # Build and start the containers
-        run_docker_compose("up --build -d")
-        logger.info("Docker Compose stack is up")
-        
-        # Execute run.sh inside the container
-        logger.info("Executing run.sh inside the container...")
-        result = subprocess.run(
-            "docker-compose exec -T vpn /opt/src/run.sh",
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            logger.info("run.sh executed successfully")
-        else:
-            logger.error(f"run.sh execution failed: {result.stderr}")
-            
-    except Exception as e:
-        logger.error(f"Startup error: {e}")
-        raise
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    try:
-        logger.info("Stopping Docker Compose stack...")
-        run_docker_compose("down")
-        logger.info("Docker Compose stack is down")
-    except Exception as e:
-        logger.error(f"Shutdown error: {e}")
-
-@app.get("/")
-async def root():
-    return {"message": "VPN Server is running"}
-
-@app.get("/status")
-async def status():
-    try:
-        result = subprocess.run(
-            "docker-compose ps --format json",
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            return {"status": "running", "details": result.stdout}
-        return {"status": "not_running", "details": result.stderr}
-    except Exception as e:
-        logger.error(f"Status check error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/logs")
-async def logs():
-    try:
-        return {"logs": run_docker_compose("logs")}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/restart")
-async def restart():
-    try:
-        run_docker_compose("restart")
-        return {"message": "Services restarted successfully"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/vpn-details")
-async def vpn_details():
-    try:
-        # Get VPN connection details from the container
-        result = subprocess.run(
-            "docker-compose exec -T vpn cat /etc/ipsec.d/vpn-gen.env",
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            return {"vpn_details": result.stdout}
-        
-        # If vpn-gen.env doesn't exist, try getting details from container logs
-        logs_result = subprocess.run(
-            "docker-compose logs vpn | grep -A 4 'Connect to your new VPN with these details:'",
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        if logs_result.returncode == 0:
-            return {"vpn_details": logs_result.stdout}
-            
-        return {"error": "Could not retrieve VPN details"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+from fastapi import FastAPI, HTTPException
+import subprocess
+import os
+import logging
+import threading
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+def run_setup_script():
+    """
+    Executes the run.sh script with root privileges.
+    The script is expected to be at /opt/src/run.sh inside the container.
+    """
+    script_path = "/opt/src/run.sh"
+    logger.info(f"Attempting to execute setup script: {script_path}")
+    
+    # The container is running as root by default, so we don't need 'sudo'.
+    # We execute the script directly.
+    try:
+        # Use subprocess.run to execute the script and wait for it to finish
+        # We capture output for logging/debugging.
+        result = subprocess.run(
+            ["/bin/bash", script_path],
+            check=True,  # Raise an exception for non-zero exit codes
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True
+        )
+        logger.info("Setup script executed successfully.")
+        logger.info(f"Script output:\n{result.stdout}")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Setup script failed with exit code {e.returncode}.")
+        logger.error(f"Script output:\n{e.stdout}")
+        # Depending on the application's requirement, we might want to exit here
+        # or just log the error and continue with the web server.
+        # For a critical setup script like this VPN one, failure is critical.
+        # We will log and let the main thread decide if it should exit.
+        # For now, we just log the error.
+    except FileNotFoundError:
+        logger.error(f"Setup script not found at {script_path}")
+    except Exception as e:
+        logger.error(f"An unexpected error occurred during script execution: {e}")
+
+# Run the setup script in a separate thread or before the uvicorn server starts.
+# Since the setup script is likely long-running and critical, we'll run it 
+# synchronously before starting the web server. If the web server is meant to 
+# serve status while the script runs, we'd use a thread. Given the context 
+# of a VPN setup, the setup must complete first.
+
+# We will use a simple function call before uvicorn.run.
+# For a production-ready FastAPI app, this logic should be in a startup event handler,
+# but for a simple script, running it before uvicorn.run is sufficient.
+
+if __name__ == "__main__":
+    # 1. Run the setup script
+    run_setup_script()
+    
+    # 2. Start the web server
+    import uvicorn
+    logger.info("Starting Uvicorn server...")
+    uvicorn.run(app, host="0.0.0.0", port=8000)