Initial commit: Flask backend, Dockerfile, GKE workflow template, and documentation template

Author: MirkoZETA

.github/workflows/gke-cd.yml

@@ -0,0 +1,62 @@
+name: Backend CI/CD to GKE
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build-and-push-docker:
+    name: Build and Push Docker Image
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up Google Cloud SDK
+      uses: google-github-actions/setup-gcloud@v1
+      with:
+        service_account_key: ${{ secrets.GKE_SA_KEY }} # Configure this secret in GitHub Actions
+        project_id: ${{ secrets.GKE_PROJECT_ID }} # Configure this secret in GitHub Actions
+
+    - name: Enable Docker Credential Helper
+      run: |-
+        gcloud auth configure-docker
+
+    - name: Build Docker image
+      run: |-
+        docker build --tag gcr.io/${{ secrets.GKE_PROJECT_ID }}/mi-backend-simulacion:${GITHUB_SHA} .
+
+    - name: Push Docker image to GCR
+      run: |-
+        docker push gcr.io/${{ secrets.GKE_PROJECT_ID }}/mi-backend-simulacion:${GITHUB_SHA}
+
+  deploy-to-gke:
+    name: Deploy to GKE
+    needs: build-and-push-docker
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Set up Google Cloud SDK
+      uses: google-github-actions/setup-gcloud@v1
+      with:
+        service_account_key: ${{ secrets.GKE_SA_KEY }} # Configure this secret in GitHub Actions
+        project_id: ${{ secrets.GKE_PROJECT_ID }} # Configure this secret in GitHub Actions
+        cluster_name: tu-cluster-gke # Reemplaza with your GKE cluster name
+        cluster_zone: tu-zona-gke # Reemplaza with your GKE cluster zone
+
+    - name: Get Kubernetes credentials
+      run: |-
+        gcloud container clusters get-credentials tu-cluster-gke --zone tu-zona-gke --project ${{ secrets.GKE_PROJECT_ID }} # Reemplaza with your cluster and zone
+
+    - name: Deploy to GKE (Ejemplo Básico - Necesitas Adaptar!)
+      run: |-
+        # This is a VERY basic example. YOU MUST ADAPT THIS TO YOUR KUBERNETES DEPLOYMENT.
+        # Normally you would use a Kubernetes Deployment YAML file and kubectl apply -f deployment.yaml
+        # Here, we just update the image of an existing Deployment named 'mi-backend-deployment' (example).
+        kubectl set image deployment/mi-backend-deployment mi-backend-container=gcr.io/${{ secrets.GKE_PROJECT_ID }}/mi-backend-simulacion:${GITHUB_SHA}

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+simulation.out

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.9-slim-buster
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+
+COPY backend.py ./
+COPY src ./src
+COPY networks ./networks
+COPY bitrates ./bitrates
+
+
+RUN g++ -O3 -o simulation.out main.cpp
+
+# - 'backend:app' especifica el módulo 'backend.py' y la instancia de Flask 'app'.
+# - '--bind 0.0.0.0:8080' hace que Gunicorn escuche en todas las interfaces (0.0.0.0) en el puerto 8080 dentro del contenedor.
+# - '--workers 3' configura Gunicorn para usar 3 procesos de trabajo para manejar las peticiones.
+CMD ["gunicorn", "backend:app", "--bind", "0.0.0.0:8080", "--workers", "3"]

README.md

@@ -0,0 +1,53 @@
+# Flask Simulation Backend API
+
+This is a Flask-based backend API that runs C++ library Flex Net Sim.
+
+## Prerequisites
+
+*   Python 3.9 or higher
+*   g++ (GNU C++ Compiler)
+*   Docker (for containerization)
+*   Google Cloud SDK (for deployment to GKE)
+*   A Google Cloud Project with Google Kubernetes Engine (GKE) and Google Container Registry (GCR) enabled.
+
+## Getting Started (Local Development)
+
+1.  **Clone the repository:**
+    ```bash
+    git clone [repository-url]
+    cd flask-simulation-backend
+    ```
+
+2.  **Create a Python virtual environment (recommended):**
+    ```bash
+    python3 -m venv .venv
+    source .venv/bin/activate  # On Linux/macOS
+    .venv\Scripts\activate  # On Windows
+    ```
+
+3.  **Install Python dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+4.  **Compile the C++ simulation (this happens automatically on startup):**
+    When you run the Flask backend for the first time, it will compile `main.cpp` to `simulation.out`.
+
+5.  **Run the Flask backend:**
+    ```bash
+    python backend.py
+    ```
+    The backend will be accessible at `http://127.0.0.1:5000`.
+
+6.  **Send simulation requests using `curl` or a frontend application:**
+    Example `curl` request:
+    ```bash
+    curl -X POST -H "Content-Type: application/json" -d '{"algorithm": "FirstFit", "networkType": 1, "bitrate": "bitrate"}' [http://127.0.0.1:5000/run_simulation](http://127.0.0.1:5000/run_simulation)
+    ```
+
+## Dockerization
+
+To build the Docker image:
+
+```bash
+docker build -t mi-backend-simulacion .

backend.py

@@ -0,0 +1,104 @@
+# backend.py (Flask API)
+from flask import Flask, request, jsonify
+import subprocess
+import os
+import logging # Import the logging module
+from flask_cors import CORS # Import Flask-CORS (if you use it)
+
+# --- Flask Setup --- 
+app = Flask(__name__)
+CORS(app, resources={r"/run_simulation": {"origins": 'http://localhost:5000'}}) # <-- UNCOMMENT and SET ORIGIN
+
+# --- Setup and Compilation ---
+SIMULATION_EXECUTABLE = "./src/simulation.out"
+COMPILE_ERROR = None # Global variable to store compilation errors
+
+# --- Logging Setup ---
+logging.basicConfig(level=logging.INFO,  # Set the minimum level to INFO (or DEBUG for more verbosity)
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__) # Get a logger instance for this module
+
+# --- Compilation ---
+def compile_simulation():
+    """Compiles the simulation at startup. Logs compilation details."""
+    global COMPILE_ERROR
+
+    # If file exists, delete it.
+    if os.path.exists(SIMULATION_EXECUTABLE):
+        logger.info(f"{SIMULATION_EXECUTABLE} already exists, deleting.") # Use logger.info instead of print
+        os.remove(SIMULATION_EXECUTABLE)
+
+    logger.info("Compiling simulation...") # Use logger.info
+    compile_result = subprocess.run(["g++", "-O3", "-o", SIMULATION_EXECUTABLE, "./src/main.cpp"], capture_output=True, text=True)
+    if compile_result.returncode != 0:
+        COMPILE_ERROR = {"error": "Compilation failed", "details": compile_result.stderr}
+        logger.error(f"Compilation failed: {COMPILE_ERROR['error']} - Details: {COMPILE_ERROR['details']}") # Use logger.error for errors
+        return False
+    logger.info("Simulation compiled successfully.") # Use logger.info
+    return True
+
+# --- Run Simulation Endpoint ---
+@app.route("/run_simulation", methods=["POST"])
+@app.route("/run_simulation", methods=["POST"])
+def run_simulation():
+    """Runs the simulation with parameters provided in the request."""
+    global COMPILE_ERROR
+    if COMPILE_ERROR:
+        return jsonify(COMPILE_ERROR), 500 # Return compilation error if it exists from startup
+
+    if not os.path.exists(SIMULATION_EXECUTABLE): # Double check if executable exists
+        return jsonify({"error": "Simulation executable not found. Contact developer."}), 400
+
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Missing JSON parameters in request body."}), 400
+
+        # Parameters, use default values if not provided
+        algorithm = data.get("algorithm", "FirstFit")
+        networkType = data.get("networkType", 1)
+        goal_connections = data.get("goal_connections", 100000)
+        confidence = data.get("confidence", 0.05)
+        lambda_param = data.get("lambda", 1)
+        mu = data.get("mu", 10)
+        network = data.get("network", "NSFNet")
+        bitrate = data.get("bitrate", "bitrate")
+
+        # Construct command for subprocess
+        command = [
+            f"./{SIMULATION_EXECUTABLE}",
+            str(algorithm),
+            str(networkType),
+            str(goal_connections),
+            str(confidence),
+            str(lambda_param),
+            str(mu),
+            str(network),
+            str(bitrate)
+        ]
+        logger.debug(f"Running simulation with command: {' '.join(command)}") # Debug log for command
+
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        output, error = process.communicate()
+
+        if process.returncode != 0:
+            logger.error(f"Simulation execution failed. Return code: {process.returncode}, Details: {error.strip()}") # Error log for simulation failure
+            return jsonify({"error": "Simulation execution failed", "details": error.strip()}), 500
+
+        # Return output in a structured JSON format
+        return jsonify({"output": output.strip(), "error": error.strip()}), 200
+
+    except Exception as e:
+        logger.exception("Unexpected error during run_simulation:")
+        return jsonify({"error": "An unexpected error occurred. Contact developer.", "details": str(e)}), 500
+
+# --- Run Setup on Application Start ---
+with app.app_context(): # Context needed to call route function outside request
+    compile_success = compile_simulation() # Call compile directly at startup
+
+if __name__ == "__main__":
+    if not compile_success:
+        print("Application start aborted due to compilation error. Please check /setup endpoint.")
+    else:
+        print("Starting Flask application...")
+        app.run(debug=True, host="0.0.0.0") # Enable debug for development

bitrates/bitrate.json

@@ -0,0 +1,48 @@
+{
+    "10": [
+        {
+            "BPSK": {
+                "slots": 1,
+                "reach": 5520
+            }
+        }
+    ],
+    "40": [
+        {
+            "BPSK": {
+                "slots": 4,
+                "reach": 5520
+            }
+        },
+        {
+            "QPSK": {
+                "slots": 2,
+                "reach": 5520
+            }
+        }
+    ],
+    "100": [
+        {
+            "BPSK": {
+                "slots": 8,
+                "reach": 5520
+            }
+        }
+    ],
+    "400": [
+        {
+            "BPSK": {
+                "slots": 32,
+                "reach": 5520
+            }
+        }
+    ],
+    "1000": [
+        {
+            "BPSK": {
+                "slots": 80,
+                "reach": 5520
+            }
+        }
+    ]
+}