Merge branch 'next' into feat/blueprint_create

Author: SpliiT

.gitignore

@@ -9,6 +9,6 @@ __pycache__
 .vscode
 uploads
 node_modules
-schemas.json
 .mypy_cache
 *.db
+opengeodeweb_back_schemas.json

package-lock.json

@@ -8,4 +8,3 @@ geode-viewables==3.3.2
 flask[async]==3.1.2
 flask-cors==6.0.1
 werkzeug==3.1.2
-flask-sqlalchemy==3.1.1

requirements.in

@@ -4,34 +4,29 @@
 #
 #    pip-compile
 #
-asgiref==3.10.0
+asgiref>=3
     # via flask
-blinker==1.9.0
+blinker>=1
     # via flask
-click==8.3.0
+click>=8
     # via flask
-flask[async]==3.1.2
+flask[async]>=3
     # via
     #   -r requirements.in
     #   flask-cors
-    #   flask-sqlalchemy
 flask-cors==6.0.1
     # via -r requirements.in
-flask-sqlalchemy==3.1.1
-    # via -r requirements.in
-geode-common==33.11.3
+geode-common==33.11.0
     # via
     #   -r requirements.in
     #   geode-viewables
 geode-viewables==3.3.2
     # via -r requirements.in
-greenlet==3.2.4
-    # via sqlalchemy
-itsdangerous==2.2.0
+itsdangerous>=2
     # via flask
-jinja2==3.1.6
+jinja2>=3
     # via flask
-markupsafe==3.0.3
+markupsafe>=3
     # via
     #   flask
     #   jinja2
@@ -59,12 +54,9 @@ opengeode-io==7.4.2
     #   -r requirements.in
     #   geode-viewables
     #   opengeode-geosciencesio
-sqlalchemy==2.0.44
-    # via flask-sqlalchemy
-typing-extensions==4.15.0
-    # via sqlalchemy
 werkzeug==3.1.2
     # via
     #   -r requirements.in
     #   flask
     #   flask-cors
+

requirements.txt

@@ -13,7 +13,7 @@
 from opengeodeweb_back.routes import blueprint_routes
 from opengeodeweb_back.routes.models import blueprint_models
 from opengeodeweb_back.routes.create import blueprint_create
-from opengeodeweb_microservice.database.connection import init_database
+from opengeodeweb_microservice.database import connection
 
 """ Global config """
 app: Flask = flask.Flask(__name__)
@@ -34,6 +34,17 @@
     app.config.get("SECONDS_BETWEEN_SHUTDOWNS") or 60.0
 )
 
+
+@app.before_request
+def before_request() -> None:
+    utils_functions.before_request(flask.current_app)
+
+
+@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",
@@ -140,12 +151,14 @@ def run_server() -> None:
         f"Origins: {args.allowed_origins}",
         flush=True,
     )
-    db_filename: str = app.config.get("DATABASE_FILENAME") or "database.db"
+
+    db_filename: str = app.config.get("DATABASE_FILENAME") or "project.db"
     db_path = os.path.join(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
-    init_database(app, db_filename)
+
+    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)
 

src/opengeodeweb_back/app.py

@@ -17,20 +17,6 @@
 routes = flask.Blueprint("routes", __name__, url_prefix="/opengeodeweb_back")
 
 
-@routes.before_request
-def before_request():
-    if "ping" not in flask.request.path:
-        utils_functions.increment_request_counter(flask.current_app)
-
-
-@routes.teardown_request
-def teardown_request(exception):
-
-    if "ping" not in flask.request.path:
-        utils_functions.decrement_request_counter(flask.current_app)
-        utils_functions.update_last_request_time(flask.current_app)
-
-
 routes.register_blueprint(
     blueprint_models.routes,
     url_prefix=blueprint_models.routes.url_prefix,
@@ -357,3 +343,17 @@ def ping():
     utils_functions.validate_request(flask.request, ping_json)
     flask.current_app.config.update(LAST_PING_TIME=time.time())
     return flask.make_response({"message": "Flask server is running"}, 200)
+
+
+with open(
+    os.path.join(schemas, "kill.json"),
+    "r",
+) as file:
+    kill_json = json.load(file)
+
+
+@routes.route(kill_json["route"], methods=kill_json["methods"])
+def kill() -> flask.Response:
+    print("Manual server kill, shutting down...", flush=True)
+    os._exit(0)
+    return flask.make_response({"message": "Flask server is dead"}, 200)

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -0,0 +1,10 @@
+{
+  "route": "/kill",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {},
+  "required": [],
+  "additionalProperties": false
+}

src/opengeodeweb_back/routes/schemas/kill.json

@@ -4,7 +4,6 @@
 import time
 import zipfile
 from collections.abc import Callable
-from typing import Any
 from concurrent.futures import ThreadPoolExecutor
 
 # Third party imports
@@ -41,13 +40,28 @@ def update_last_request_time(current_app: flask.Flask) -> None:
         current_app.config.update(LAST_REQUEST_TIME=LAST_REQUEST_TIME)
 
 
+def terminate_session(exception: BaseException | None) -> None:
+    session = flask.g.pop("session", None)
+    if session is None:
+        return
+    if exception is None:
+        session.commit()
+    else:
+        session.rollback()
+    session.close()
+
+
 def before_request(current_app: flask.Flask) -> None:
     increment_request_counter(current_app)
+    flask.g.session = get_session()
 
 
-def teardown_request(current_app: flask.Flask) -> None:
+def teardown_request(
+    current_app: flask.Flask, exception: BaseException | None = None
+) -> None:
     decrement_request_counter(current_app)
     update_last_request_time(current_app)
+    terminate_session(exception)
 
 
 def kill_task(current_app: flask.Flask) -> None:
@@ -97,7 +111,7 @@ def validate_request(request: flask.Request, schema: dict[str, str]) -> None:
 
 
 def set_interval(
-    function: Callable[[Any], None], seconds: float, args: Any
+    function: Callable[[flask.Flask], None], seconds: float, args: flask.Flask
 ) -> threading.Timer:
     def function_wrapper() -> None:
         set_interval(function, seconds, args)
@@ -114,7 +128,7 @@ def extension_from_filename(filename: str) -> str:
 
 
 def send_file(
-    upload_folder: str, saved_files: str, new_file_name: str
+    upload_folder: str, saved_files: list[str], new_file_name: str
 ) -> flask.Response:
     if len(saved_files) == 1:
         mimetype = "application/octet-binary"
@@ -162,19 +176,10 @@ def create_data_folder_from_id(data_id: str) -> str:
 
 def save_all_viewables_and_return_info(
     geode_object: str,
-    data: Any,
-    input_file: str | None = None,
-    additional_files: list[str] | None = None,
-) -> dict[str, Any]:
-    if additional_files is None:
-        additional_files = []
-
-    data_entry = Data.create(
-        geode_object=geode_object,
-        input_file=input_file,
-        additional_files=additional_files,
-    )
-    data_path = create_data_folder_from_id(data_entry.id)
+    data: object,
+    data_entry: Data,
+    data_path: str,
+) -> dict[str, str | list[str]]:
     with ThreadPoolExecutor() as executor:
         native_future = executor.submit(
             geode_functions.save,
@@ -202,38 +207,40 @@ def save_all_viewables_and_return_info(
         data_entry.viewable_file_name = os.path.basename(saved_viewable_file_path)
         data_entry.light_viewable = os.path.basename(saved_light_viewable_file_path)
 
-        session = get_session()
-        if session:
-            session.commit()
-
         return {
             "native_file_name": data_entry.native_file_name,
             "viewable_file_name": data_entry.viewable_file_name,
             "id": data_entry.id,
             "object_type": geode_functions.get_object_type(geode_object),
             "binary_light_viewable": binary_light_viewable.decode("utf-8"),
             "geode_object": data_entry.geode_object,
-            "input_files": data_entry.input_file,
+            "input_file": data_entry.input_file,
             "additional_files": data_entry.additional_files,
         }
 
 
 def generate_native_viewable_and_light_viewable_from_object(
-    geode_object: str, data: Any
-) -> dict[str, Any]:
-    return save_all_viewables_and_return_info(geode_object, data, input_file="")
+    geode_object: str, data: object
+) -> dict[str, str | list[str]]:
+    data_entry = Data.create(
+        geode_object=geode_object,
+        input_file="",
+        additional_files=[],
+    )
+    data_path = create_data_folder_from_id(data_entry.id)
+    return save_all_viewables_and_return_info(geode_object, data, data_entry, data_path)
 
 
 def generate_native_viewable_and_light_viewable_from_file(
     geode_object: str, input_filename: str
-) -> dict[str, Any]:
-    temp_data_entry = Data.create(
+) -> dict[str, str | list[str]]:
+    data_entry = Data.create(
         geode_object=geode_object,
         input_file=input_filename,
         additional_files=[],
     )
 
-    data_path = create_data_folder_from_id(temp_data_entry.id)
+    data_path = create_data_folder_from_id(data_entry.id)
 
     full_input_filename = geode_functions.upload_file_path(input_filename)
     copied_full_path = os.path.join(
@@ -258,14 +265,10 @@ def generate_native_viewable_and_light_viewable_from_file(
 
     data = geode_functions.load(geode_object, copied_full_path)
 
-    session = get_session()
-    if session:
-        session.delete(temp_data_entry)
-        session.flush()
-
+    data_entry.additional_files = additional_files_copied
     return save_all_viewables_and_return_info(
         geode_object,
         data,
-        input_file=input_filename,
-        additional_files=additional_files_copied,
+        data_entry,
+        data_path,
     )

src/opengeodeweb_back/utils_functions.py

@@ -36,7 +36,7 @@ def configure_test_environment() -> Generator[None, None, None]:
     print("Current working directory:", os.getcwd())
     print("Directory contents:", os.listdir("."))
 
-    init_database(app, db_path)
+    init_database(db_path)
     os.environ["TEST_DB_PATH"] = str(db_path)
 
     yield