Feat(App): create_app, register_ogw_back_blueprints, run_server

Author: JulienChampagnol

src/opengeodeweb_back/app.py

@@ -14,141 +14,133 @@
 from opengeodeweb_back.routes.create import blueprint_create
 from opengeodeweb_microservice.database import connection
 
-""" Global config """
-app: Flask = flask.Flask(__name__)
-
-""" Config variables """
-FLASK_DEBUG = True if os.environ.get("FLASK_DEBUG", default=None) == "True" else False
-if FLASK_DEBUG == False:
-    app.config.from_object(app_config.ProdConfig)
-else:
-    app.config.from_object(app_config.DevConfig)
-DEFAULT_HOST: str = app.config.get("DEFAULT_HOST") or "localhost"
-DEFAULT_PORT: int = int(app.config.get("DEFAULT_PORT") or 5000)
-DEFAULT_DATA_FOLDER_PATH: str = app.config.get("DEFAULT_DATA_FOLDER_PATH") or "./data"
-ORIGINS: Any = app.config.get("ORIGINS")
-TIMEOUT: int = int(app.config.get("MINUTES_BEFORE_TIMEOUT") or 30)
-SSL: Any = app.config.get("SSL")
-SECONDS_BETWEEN_SHUTDOWNS: float = float(
-    app.config.get("SECONDS_BETWEEN_SHUTDOWNS") or 60.0
-)
-
-
-@app.before_request
-def before_request() -> flask.Response | None:
-    if flask.request.method == "OPTIONS":
-        response = flask.make_response()
-        response.headers["Access-Control-Allow-Methods"] = "GET,POST,PUT,DELETE,OPTIONS"
-        return response
-    utils_functions.before_request(flask.current_app)
-    return None
-
-
-@app.teardown_request
-def teardown_request(exception: BaseException | None) -> None:
-    utils_functions.teardown_request(flask.current_app, exception)
-
-
-app.register_blueprint(
-    blueprint_routes.routes,
-    url_prefix="/opengeodeweb_back",
-    name="opengeodeweb_back",
-)
-app.register_blueprint(
-    blueprint_models.routes,
-    url_prefix="/opengeodeweb_back/models",
-    name="opengeodeweb_models",
-)
-app.register_blueprint(
-    blueprint_create.routes,
-    url_prefix="/opengeodeweb_back/create",
-    name="opengeodeweb_create",
-)
-
-if FLASK_DEBUG == False:
-    utils_functions.set_interval(
-        utils_functions.kill_task, SECONDS_BETWEEN_SHUTDOWNS, app
+def create_app(name: str) -> flask.Flask:
+    app = flask.Flask(name)
+
+    """ Config variables """
+    FLASK_DEBUG = True if os.environ.get("FLASK_DEBUG", default=None) == "True" else False
+    if FLASK_DEBUG == False:
+        app.config.from_object(app_config.ProdConfig)
+    else:
+        app.config.from_object(app_config.DevConfig)
+    
+    if FLASK_DEBUG == False:
+        SECONDS_BETWEEN_SHUTDOWNS: float = float(
+            app.config.get("SECONDS_BETWEEN_SHUTDOWNS") or 60.0
+        )
+        utils_functions.set_interval(
+            utils_functions.kill_task, SECONDS_BETWEEN_SHUTDOWNS, app
+        )
+
+    @app.before_request
+    def before_request() -> flask.Response | None:
+        if flask.request.method == "OPTIONS":
+            response = flask.make_response()
+            response.headers["Access-Control-Allow-Methods"] = "GET,POST,PUT,DELETE,OPTIONS"
+            return response
+        utils_functions.before_request(flask.current_app)
+        return None
+
+    @app.teardown_request
+    def teardown_request(exception: BaseException | None) -> None:
+        utils_functions.teardown_request(flask.current_app, exception)
+
+    @app.errorhandler(HTTPException)
+    def errorhandler(exception: HTTPException) -> tuple[dict[str, Any], int] | Response:
+        return utils_functions.handle_exception(exception)
+
+
+    @app.errorhandler(Exception)
+    def handle_generic_exception(exception: Exception) -> Response:
+        print("\033[91mError:\033[0m \033[91m" + str(exception) + "\033[0m", flush=True)
+        return flask.make_response({"description": str(exception)}, 500)
+
+
+    @app.route(
+        "/error",
+        methods=["POST"],
     )
+    def return_error() -> Response:
+        flask.abort(500, f"Test")
+        return flask.make_response({}, 500)
 
 
-@app.errorhandler(HTTPException)
-def errorhandler(exception: HTTPException) -> tuple[dict[str, Any], int] | Response:
-    return utils_functions.handle_exception(exception)
+    @app.route("/", methods=["POST"])
+    @cross_origin()
+    def root() -> Response:
+        return flask.make_response({}, 200)
 
 
-@app.errorhandler(Exception)
-def handle_generic_exception(exception: Exception) -> Response:
-    print("\033[91mError:\033[0m \033[91m" + str(exception) + "\033[0m", flush=True)
-    return flask.make_response({"description": str(exception)}, 500)
+    @app.route("/kill", methods=["POST"])
+    @cross_origin()
+    def kill() -> None:
+        print("Manual server kill, shutting down...", flush=True)
+        os._exit(0)
 
+    return app
 
-@app.route(
-    "/error",
-    methods=["POST"],
-)
-def return_error() -> Response:
-    flask.abort(500, f"Test")
-    return flask.make_response({}, 500)
-
-
-@app.route("/", methods=["POST"])
-@cross_origin()
-def root() -> Response:
-    return flask.make_response({}, 200)
-
-
-@app.route("/kill", methods=["POST"])
-@cross_origin()
-def kill() -> None:
-    print("Manual server kill, shutting down...", flush=True)
-    os._exit(0)
-
+def register_ogw_back_blueprints(app: flask.Flask) -> None:
+    app.register_blueprint(
+        blueprint_routes.routes,
+        url_prefix="/opengeodeweb_back",
+        name="opengeodeweb_back",
+    )
+    app.register_blueprint(
+        blueprint_models.routes,
+        url_prefix="/opengeodeweb_back/models",
+        name="opengeodeweb_models",
+    )
+    app.register_blueprint(
+        blueprint_create.routes,
+        url_prefix="/opengeodeweb_back/create",
+        name="opengeodeweb_create",
+    )
 
-def run_server() -> None:
+def run_server(app: Flask) -> None:
     parser = argparse.ArgumentParser(
         prog="OpenGeodeWeb-Back", description="Backend server for OpenGeodeWeb"
     )
-    parser.add_argument("--host", type=str, default=DEFAULT_HOST, help="Host to run on")
+    parser.add_argument("--host", type=str, default=app.config.get("DEFAULT_HOST"), help="Host to run on")
     parser.add_argument(
-        "-p", "--port", type=int, default=DEFAULT_PORT, help="Port to listen on"
+        "-p", "--port", type=int, default=app.config.get("DEFAULT_PORT"), help="Port to listen on"
     )
     parser.add_argument(
         "-d",
         "--debug",
-        default=FLASK_DEBUG,
+        default=app.config.get("FLASK_DEBUG"),
         help="Whether to run in debug mode",
         action="store_true",
     )
     parser.add_argument(
         "-dfp",
         "--data_folder_path",
         type=str,
-        default=DEFAULT_DATA_FOLDER_PATH,
+        default=app.config.get("DEFAULT_DATA_FOLDER_PATH"),
         help="Path to the folder where data is stored",
     )
     parser.add_argument(
         "-ufp",
         "--upload_folder_path",
         type=str,
-        default=DEFAULT_DATA_FOLDER_PATH,
+        default=app.config.get("DEFAULT_DATA_FOLDER_PATH"),
         help="Path to the folder where uploads are stored",
     )
     parser.add_argument(
         "-origins",
         "--allowed_origins",
-        default=ORIGINS,
+        default=app.config.get("ORIGINS"),
         help="Origins that are allowed to connect to the server",
     )
     parser.add_argument(
         "-t",
         "--timeout",
-        default=TIMEOUT,
+        default=app.config.get("MINUTES_BEFORE_TIMEOUT"),
         help="Number of minutes before the server times out",
     )
     args = parser.parse_args()
     app.config.update(DATA_FOLDER_PATH=args.data_folder_path)
     app.config.update(
-        EXTENSIONS_FOLDER_PATH=os.path.join(args.data_folder_path, "extensions")
+        EXTENSIONS_FOLDER_PATH=os.path.join(str(args.data_folder_path), "extensions")
     )
     app.config.update(UPLOAD_FOLDER=args.upload_folder_path)
     app.config.update(MINUTES_BEFORE_TIMEOUT=args.timeout)
@@ -161,16 +153,12 @@ def run_server() -> None:
     )
 
     db_filename: str = app.config.get("DATABASE_FILENAME") or "project.db"
-    db_path = os.path.join(args.data_folder_path, db_filename)
+    db_path = os.path.join(str(args.data_folder_path), db_filename)
     os.makedirs(os.path.dirname(db_path), exist_ok=True)
     app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{db_path}"
     app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
 
     connection.init_database(db_path)
     print(f"Database initialized at: {db_path}", flush=True)
-    app.run(debug=args.debug, host=args.host, port=args.port, ssl_context=SSL)
-
-
-# ''' Main '''
-if __name__ == "__main__":
-    run_server()
+    app.run(debug=args.debug, host=args.host, port=args.port, ssl_context=app.config.get("SSL"))
+    print("Server stopped", flush=True)

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -17,9 +17,9 @@
 from opengeodeweb_microservice.database import connection
 
 # Local application imports
-from .models import blueprint_models
-from . import schemas
 from opengeodeweb_back import geode_functions, utils_functions
+from opengeodeweb_back.routes import schemas
+from opengeodeweb_back.routes.models import blueprint_models
 from opengeodeweb_back.geode_objects import geode_objects
 from opengeodeweb_back.geode_objects.types import geode_object_type
 from opengeodeweb_back.geode_objects.geode_mesh import GeodeMesh
@@ -544,17 +544,12 @@ def import_extension() -> flask.Response:
     with zipfile.ZipFile(vext_file.stream) as zip_archive:
         zip_archive.extractall(extension_path)
 
-    # Find the extracted files
-    dist_path = os.path.join(extension_path, "dist")
-    if not os.path.exists(dist_path):
-        flask.abort(400, "Invalid .vext file: missing dist folder")
-
     # Look for the backend executable and frontend JS
     backend_executable = None
     frontend_file = None
 
-    for file in os.listdir(dist_path):
-        file_path = os.path.join(dist_path, file)
+    for file in os.listdir(extension_path):
+        file_path = os.path.join(extension_path, file)
         if os.path.isfile(file_path):
             if file.endswith(".es.js"):
                 frontend_file = file_path