feat(ping route): updates LAST_PING_TIME

BREAKING CHANGE: functions moved to utils_functions.py

Author: JulienChampagnol

config.py

@@ -25,7 +25,7 @@ class ProdConfig(Config):
 
 class DevConfig(Config):
     SSL = None
-    ORIGINS = "http://localhost:3000"
+    ORIGINS = ["*"]
     MINUTES_BEFORE_TIMEOUT = "1000"
     SECONDS_BETWEEN_SHUTDOWNS = "60"
     DATA_FOLDER = "./data/"

src/opengeodeweb_back/geode_functions.py

@@ -1,17 +1,10 @@
 # Standard library imports
 import os
-import time
-import threading
-import uuid
-import zipfile
 
 # Third party imports
 import flask
 import opengeode_geosciences as og_gs
 import opengeode as og
-import pkg_resources
-from jsonschema import validate
-from jsonschema.exceptions import ValidationError
 
 # Local application imports
 from .geode_objects import geode_objects_dict
@@ -200,75 +193,6 @@ def get_inspector_children(obj):
     return new_object
 
 
-def versions(list_packages: list):
-    list_with_versions = []
-    for package in list_packages:
-        list_with_versions.append(
-            {
-                "package": package,
-                "version": pkg_resources.get_distribution(package).version,
-            }
-        )
-    return list_with_versions
-
-
-def create_lock_file(
-    folder_absolute_path,
-):
-    if not os.path.exists(folder_absolute_path):
-        os.mkdir(folder_absolute_path)
-    id = uuid.uuid4()
-    file_absolute_path = f"{folder_absolute_path}/{str(id)}.txt"
-    f = open(file_absolute_path, "a")
-    f.close()
-    flask.g.UUID = id
-
-
-def create_time_file(folder_absolute_path):
-    if not os.path.exists(folder_absolute_path):
-        os.mkdir(folder_absolute_path)
-    file_path = f"{folder_absolute_path}/time.txt"
-    if not os.path.isfile(file_path):
-        f = open(file_path, "w")
-        f.close()
-
-    f = open(folder_absolute_path + "/time.txt", "w")
-    f.write(str(time.time()))
-    f.close()
-
-
-def remove_lock_file(folder_absolute_path):
-    id = flask.g.UUID
-    os.remove(f"{folder_absolute_path}/{str(id)}.txt")
-
-
-def set_interval(func, sec):
-    def func_wrapper():
-        set_interval(func, sec)
-        func()
-
-    t = threading.Timer(sec, func_wrapper)
-    t.daemon = True
-    t.start()
-    return t
-
-
-def extension_from_filename(filename):
-    return os.path.splitext(filename)[1][1:]
-
-
-def validate_request(request, schema):
-    json_data = request.get_json(force=True, silent=True)
-
-    if json_data is None:
-        json_data = {}
-
-    try:
-        validate(instance=json_data, schema=schema)
-    except ValidationError as e:
-        flask.abort(400, f"Validation error: {e.message}")
-
-
 def geographic_coordinate_systems(geode_object: str):
     if is_3D(geode_object):
         return og_gs.GeographicCoordinateSystem3D.geographic_coordinate_systems()
@@ -329,41 +253,3 @@ def create_coordinate_system(
     create_crs(
         geode_object, data, name, input_coordiante_system, output_coordiante_system
     )
-
-
-def send_file(upload_folder, saved_files, new_file_name):
-    if len(saved_files) == 1:
-        mimetype = "application/octet-binary"
-    else:
-        mimetype = "application/zip"
-        new_file_name = os.path.splitext(new_file_name)[0] + ".zip"
-        with zipfile.ZipFile(os.path.join(upload_folder, new_file_name), "w") as zipObj:
-            for saved_file_path in saved_files:
-                zipObj.write(
-                    saved_file_path,
-                    os.path.basename(saved_file_path),
-                )
-
-    response = flask.send_from_directory(
-        directory=upload_folder,
-        path=new_file_name,
-        as_attachment=True,
-        mimetype=mimetype,
-    )
-    response.headers["new-file-name"] = new_file_name
-    response.headers["Access-Control-Expose-Headers"] = "new-file-name"
-
-    return response
-
-
-def handle_exception(e):
-    response = e.get_response()
-    response.data = flask.json.dumps(
-        {
-            "code": e.code,
-            "name": e.name,
-            "description": e.description,
-        }
-    )
-    response.content_type = "application/json"
-    return response

src/opengeodeweb_back/routes/blueprint_routes.py

@@ -1,18 +1,26 @@
 # Standard library imports
 import json
 import os
+import time
 
 # Third party imports
 import flask
-import flask_cors
-from .. import geode_functions
+from .. import geode_functions, utils_functions
 import werkzeug
 import uuid
 
-
 routes = flask.Blueprint("routes", __name__)
-flask_cors.CORS(routes)
 
+@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)
 
 schemas = os.path.join(os.path.dirname(__file__), "schemas")
 
@@ -260,3 +268,19 @@ def save_viewable_file():
         },
         200,
     )
+
+
+with open(
+    os.path.join(schemas, "ping.json"),
+    "r",
+) as file:
+    ping_json = json.load(file)
+
+@routes.route(
+    ping_json["route"],
+    methods=ping_json["methods"],
+)
+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)

src/opengeodeweb_back/routes/schemas/ping.json

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

src/opengeodeweb_back/utils_functions.py

@@ -0,0 +1,124 @@
+# Standard library imports
+import os
+import threading
+import time
+import zipfile
+
+# Third party imports
+import flask
+from jsonschema import validate
+from jsonschema.exceptions import ValidationError
+import pkg_resources
+
+# Local application imports
+
+def increment_request_counter(current_app):
+    REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
+    REQUEST_COUNTER += 1
+    current_app.config.update(REQUEST_COUNTER=REQUEST_COUNTER)
+
+def decrement_request_counter(current_app):
+    REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
+    REQUEST_COUNTER -= 1
+    current_app.config.update(REQUEST_COUNTER=REQUEST_COUNTER)
+
+def update_last_request_time(current_app):
+    LAST_REQUEST_TIME = time.time()
+    current_app.config.update(LAST_REQUEST_TIME=LAST_REQUEST_TIME)
+
+
+def kill_task(current_app):
+    DESKTOP_APP = bool(current_app.config.get("DESKTOP_APP"))
+    REQUEST_COUNTER = int(current_app.config.get("REQUEST_COUNTER"))
+    LAST_PING_TIME = float(current_app.config.get("LAST_PING_TIME"))
+    LAST_REQUEST_TIME = float(current_app.config.get("LAST_REQUEST_TIME"))
+    MINUTES_BEFORE_TIMEOUT = float(current_app.config.get("MINUTES_BEFORE_TIMEOUT"))
+    current_time = time.time()
+    minutes_since_last_request = (current_time - LAST_REQUEST_TIME) / 60
+    minutes_since_last_ping = (current_time - LAST_PING_TIME) / 60
+
+    if (((minutes_since_last_request > MINUTES_BEFORE_TIMEOUT) and (DESKTOP_APP == False)) or 
+        (minutes_since_last_ping > MINUTES_BEFORE_TIMEOUT)
+        ) and (REQUEST_COUNTER == 0):
+        print("Server timed out due to inactivity, shutting down...", flush=True)
+        os._exit(0)
+
+
+
+def versions(list_packages: list):
+    list_with_versions = []
+    for package in list_packages:
+        list_with_versions.append(
+            {
+                "package": package,
+                "version": pkg_resources.get_distribution(package).version,
+            }
+        )
+    return list_with_versions
+
+
+
+def validate_request(request, schema):
+    json_data = request.get_json(force=True, silent=True)
+
+    if json_data is None:
+        json_data = {}
+
+    try:
+        validate(instance=json_data, schema=schema)
+    except ValidationError as e:
+        flask.abort(400, f"Validation error: {e.message}")
+
+
+
+def set_interval(func, sec, args=None):
+    def func_wrapper():
+        set_interval(func, sec, args)
+        func(args)
+
+    t = threading.Timer(sec, func_wrapper)
+    t.daemon = True
+    t.start()
+    return t
+
+
+def extension_from_filename(filename):
+    return os.path.splitext(filename)[1][1:]
+
+
+def send_file(upload_folder, saved_files, new_file_name):
+    if len(saved_files) == 1:
+        mimetype = "application/octet-binary"
+    else:
+        mimetype = "application/zip"
+        new_file_name = os.path.splitext(new_file_name)[0] + ".zip"
+        with zipfile.ZipFile(os.path.join(upload_folder, new_file_name), "w") as zipObj:
+            for saved_file_path in saved_files:
+                zipObj.write(
+                    saved_file_path,
+                    os.path.basename(saved_file_path),
+                )
+
+    response = flask.send_from_directory(
+        directory=upload_folder,
+        path=new_file_name,
+        as_attachment=True,
+        mimetype=mimetype,
+    )
+    response.headers["new-file-name"] = new_file_name
+    response.headers["Access-Control-Expose-Headers"] = "new-file-name"
+
+    return response
+
+
+def handle_exception(e):
+    response = e.get_response()
+    response.data = flask.json.dumps(
+        {
+            "code": e.code,
+            "name": e.name,
+            "description": e.description,
+        }
+    )
+    response.content_type = "application/json"
+    return response