psr-factory 5.0.0b21__py3-none-win_amd64.whl → 5.0.0b67__py3-none-win_amd64.whl

psr/execqueue/server.py

@@ -1,10 +1,14 @@
 import hashlib
+import os
 import queue
 import shutil
 import sys
 import threading
 import time
 import zipfile
+import subprocess
+import shlex
+import logging
 from dotenv import load_dotenv
 from flask import (
     Flask,
@@ -33,16 +37,56 @@ os.makedirs(TEMPORARY_UPLOAD_FOLDER, exist_ok=True)
 
 load_dotenv()
 
+# Configure logging: write to server.log inside STORAGE_PATH and to stdout
+log_file = os.path.join(STORAGE_PATH, 'server.log')
+os.makedirs(os.path.dirname(log_file), exist_ok=True)
+fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
+# Create handlers
+fh = logging.FileHandler(log_file, mode='a', encoding='utf-8')
+fh.setLevel(logging.INFO)
+fh.setFormatter(fmt)
+sh = logging.StreamHandler(sys.stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(fmt)
+
+# Configure the root logger with our handlers so all loggers propagate here
+root = logging.getLogger()
+root.setLevel(logging.INFO)
+root.handlers = []
+root.addHandler(fh)
+root.addHandler(sh)
+
+# Create module logger that will propagate to root (do not add handlers here)
+logger = logging.getLogger('execqueue')
+logger.setLevel(logging.INFO)
+logger.propagate = True
+
+# Let Flask/Werkzeug propagate to root logger (so their messages go to server.log)
+logging.getLogger('werkzeug').setLevel(logging.INFO)
+logging.getLogger('werkzeug').propagate = True
+logging.getLogger('flask.app').setLevel(logging.INFO)
+logging.getLogger('flask.app').propagate = True
+
+
 
 try:
     client = psr.cloud.Client(cluster=psrcloud_cluster, verbose=True)
 except psr.cloud.CloudInputError as e:
-    print(f"Error connecting to PSR Cloud. Check user credentials: {e}")
+    logger.exception(f"Error connecting to PSR Cloud. Check user credentials: {e}")
     exit(1)
 
 _cloud_execution_case_map = {}
 
 app = Flask(__name__, root_path=os.getcwd())
+# Ensure Flask's app logger writes to the same handlers as our logger/root
+try:
+    app.logger.handlers = logger.handlers
+    app.logger.setLevel(logging.INFO)
+    app.logger.propagate = True
+except Exception:
+    # In case logger isn't ready for some reason, ignore and continue
+    pass
+
 session = None
 
 
@@ -58,12 +102,110 @@ def run_local_case(execution_id: str, case_path: str):
         psr.runner.run_sddp(case_path, sddp_path, parallel_run=False)
         success = True
     except RuntimeError as e:
-        print(f"Error running {execution_id}: {e}")
+        logger.exception(f"Error running {execution_id}: {e}")
 
     status = db.LOCAL_EXECUTION_FINISHED if success else db.LOCAL_EXECUTION_ERROR
     db.update_local_execution_status(session, execution_id, status)
 
 
+def _ensure_case_workdir(case_id: str) -> str:
+    """Ensure a working directory exists at uploads/<case_id> with extracted contents.
+    If it does not exist or is empty, extract the uploaded zip there.
+    Returns the absolute path to the working directory.
+    """
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    zip_upload_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    os.makedirs(workdir, exist_ok=True)
+
+    # If directory is empty or looks incomplete, (re)extract
+    try:
+        if not os.listdir(workdir):
+            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
+                zip_ref.extractall(workdir)
+    except FileNotFoundError:
+        # If there's no zip, still return folder (may be pre-populated)
+        pass
+    return workdir
+
+
+def run_local_module(execution_id: str, case_id: str, module_name: str) -> int:
+    """Run a configured module locally inside the case's upload workdir.
+    Returns process return code (0=success, non-zero=failure).
+    Updates LocalExecution status accordingly.
+    """
+    global session
+    # Fetch module configuration
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg or 'command' not in module_cfg:
+        logger.error(f"Module '{module_name}' not configured.")
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+        return 1
+
+    workdir = _ensure_case_workdir(case_id)
+
+    # Build command and log file path
+    cmd_tmpl = module_cfg.get('command')
+    # Allow placeholders
+    cmd = cmd_tmpl.format(case_path=workdir, case_id=case_id, module=module_name)
+    log_name = module_cfg.get('log_file', f"module_{module_name}.log")
+    log_path = os.path.join(workdir, log_name)
+
+    logger.info(f"Running module '{module_name}' for case {case_id} in {workdir}")
+    logger.debug(f"Command: {cmd}")
+
+    rc = 1
+    try:
+        # Prefer to run without shell to avoid platform-specific exit code mappings
+        # If the command starts with 'python' or references .py, build argv accordingly
+        argv = None
+        # Heuristic: if command contains .py, run with current Python executable
+        if '.py' in cmd:
+            parts = shlex.split(cmd)
+            # If the command already starts with python, use as-is; else prepend sys.executable
+            if parts[0].endswith('python') or parts[0].endswith('python.exe'):
+                argv = parts
+            else:
+                argv = [sys.executable] + parts
+        else:
+            argv = shlex.split(cmd)
+
+        with open(log_path, 'a', encoding='utf-8', errors='ignore') as logf:
+            proc = subprocess.Popen(
+                argv,
+                cwd=workdir,
+                stdout=logf,
+                stderr=logf,
+            )
+            rc = proc.wait()
+
+        # Now rc follows the subprocess return code semantics: 0 success, non-zero failure
+        status = db.LOCAL_EXECUTION_FINISHED if rc == 0 else db.LOCAL_EXECUTION_ERROR
+        db.update_local_execution_status(session, execution_id, status)
+    except Exception as e:
+        logger.exception(f"Error running module {module_name} for case {case_id}: {e}")
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+        rc = 1
+    return rc
+
+
+def _copy_tree(src: str, dst: str):
+    os.makedirs(dst, exist_ok=True)
+    for root, dirs, files in os.walk(src):
+        rel = os.path.relpath(root, src)
+        target_root = os.path.join(dst, rel) if rel != '.' else dst
+        os.makedirs(target_root, exist_ok=True)
+        for d in dirs:
+            os.makedirs(os.path.join(target_root, d), exist_ok=True)
+        for f in files:
+            s = os.path.join(root, f)
+            t = os.path.join(target_root, f)
+            try:
+                shutil.copy2(s, t)
+            except Exception:
+                # Best-effort copy; skip problematic files
+                pass
+
+
 def initialize_db():
     session, engine = db.initialize()
     return session
@@ -91,22 +233,59 @@ def run_cloud_case(execution_id: str, case_path: str):
 def process_local_execution_queue():
     global session
     while True:
-        execution_id, case_id = _execution_queue.get()
+        item = _execution_queue.get()
         try:
-            print(f"Processing {execution_id}...")
-            # Unzip the file
-            execution_extraction_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
-            os.makedirs(execution_extraction_path, exist_ok=True)
-
-            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
-
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(execution_extraction_path)
-            # Run SDDP
-            run_local_case(execution_id, execution_extraction_path)
+            # Detect item type (backward compatibility for tuple)
+            if isinstance(item, dict) and item.get('type') == 'module':
+                execution_id = item['execution_id']
+                case_id = item['case_id']
+                module_name = item['module']
+                logger.info(f"Processing module {module_name} for case {case_id} (exec {execution_id})...")
+                run_local_module(execution_id, case_id, module_name)
+            else:
+                if isinstance(item, (list, tuple)):
+                    execution_id, case_id = item
+                else:
+                    execution_id = item.get('execution_id')
+                    case_id = item.get('case_id')
+
+                logger.info(f"Processing case execution {execution_id} for case {case_id}...")
+
+                # Wait for running modules to finish; abort if any failed
+                wait_loops = 0
+                while db.any_running_modules_for_case(session, case_id):
+                    logger.info(f"Case {case_id} has running modules; waiting...")
+                    time.sleep(5)
+                    wait_loops += 1
+                    # Safety: avoid infinite wait in worker
+                    if wait_loops > 240:  # ~20 minutes
+                        break
+
+                # Check last execution per distinct module: if any last module execution failed, mark error
+                failing_modules = []
+                for mname in db.get_distinct_module_names_for_case(session, case_id):
+                    last = db.last_module_execution_for_case(session, case_id, mname)
+                    if last and last.status == db.LOCAL_EXECUTION_ERROR:
+                        failing_modules.append(mname)
+
+                if failing_modules:
+                    logger.warning(f"Case {case_id} has failed modules {failing_modules}; marking local execution {execution_id} as error and skipping run")
+                    db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+                else:
+                    # Prepare a dedicated results folder copying the current working directory (with module changes)
+                    execution_extraction_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
+                    os.makedirs(execution_extraction_path, exist_ok=True)
+                    workdir = _ensure_case_workdir(case_id)
+                    _copy_tree(workdir, execution_extraction_path)
+                    # Run SDDP
+                    run_local_case(execution_id, execution_extraction_path)
 
         except Exception as e:
-            print(f"Error processing {execution_id}: {e}")
+            # Use safe logging in case execution_id isn't available
+            try:
+                logger.exception(f"Error processing {execution_id}: {e}")
+            except Exception:
+                logger.exception(f"Error processing item: {e}")
         finally:
             _execution_queue.task_done()
 
@@ -120,14 +299,32 @@ def process_cloud_execution_queue():
     while True:
         cloud_upload_id, case_id = _cloud_upload_queue.get()
         try:
-            print(f"Processing {cloud_upload_id}...")
-            # Unzip the file
-            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
+            logger.info(f"Processing {cloud_upload_id}...")
+            # Wait for running modules to finish; abort if any failed
+            wait_loops = 0
+            while db.any_running_modules_for_case(session, case_id):
+                logger.info(f"Case {case_id} has running modules; waiting before cloud run...")
+                time.sleep(5)
+                wait_loops += 1
+                if wait_loops > 240:  # ~20 minutes
+                    break
+            # Block if the last execution of any distinct module failed
+            failing_modules = []
+            for mname in db.get_distinct_module_names_for_case(session, case_id):
+                last = db.last_module_execution_for_case(session, case_id, mname)
+                if last and last.status == db.LOCAL_EXECUTION_ERROR:
+                    failing_modules.append(mname)
+            if failing_modules:
+                logger.warning(f"Case {case_id} has failing modules in last execution {failing_modules}; skipping cloud run for upload {cloud_upload_id}")
+                # Nothing else to do; do not run in the cloud
+                continue
+            # Prepare temp folder by copying current working directory (with module changes)
             tmp_extraction_path = os.path.join(TEMPORARY_UPLOAD_FOLDER, cloud_upload_id)
-
+            workdir = _ensure_case_workdir(case_id)
+            if os.path.isdir(tmp_extraction_path):
+                shutil.rmtree(tmp_extraction_path, ignore_errors=True)
             os.makedirs(tmp_extraction_path, exist_ok=True)
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(tmp_extraction_path)
+            _copy_tree(workdir, tmp_extraction_path)
 
             # Run SDDP
             repository_id = run_cloud_case(cloud_upload_id, tmp_extraction_path)
@@ -136,14 +333,15 @@ def process_cloud_execution_queue():
             shutil.rmtree(tmp_extraction_path)
 
             execution_extraction_path = os.path.join(CLOUD_RESULTS_FOLDER, repository_id)
+            if os.path.isdir(execution_extraction_path):
+                shutil.rmtree(execution_extraction_path, ignore_errors=True)
             os.makedirs(execution_extraction_path, exist_ok=True)
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(execution_extraction_path)
+            _copy_tree(workdir, execution_extraction_path)
 
             db.register_cloud_execution(session, repository_id, cloud_upload_id, case_id)
 
         except Exception as e:
-            print(f"Error processing {cloud_upload_id}: {e}")
+            logger.exception(f"Error processing {cloud_upload_id}: {e}")
         finally:
             _cloud_upload_queue.task_done()
 
@@ -164,19 +362,19 @@ def monitor_cloud_runs():
             #check running executions
             for cloud_execution in db.get_runing_cloud_executions(session):
                 case_id = cloud_execution.repository_id
-                print(f"Checking status of {case_id}...")
+                logger.info(f"Checking status of {case_id}...")
                 status, status_msg = client.get_status(case_id)
                 if status in psr.cloud.FAULTY_TERMINATION_STATUS:
-                    print(f"Execution {case_id} finished with errors")
+                    logger.warning(f"Execution {case_id} finished with errors")
                     db.update_cloud_execution_status(session, case_id, db.CloudStatus.ERROR.value)
                 elif status == psr.cloud.ExecutionStatus.SUCCESS:
-                    print(f"Execution {case_id} finished successfully")
+                    logger.info(f"Execution {case_id} finished successfully")
                     db.update_cloud_execution_status(session, case_id, db.CloudStatus.FINISHED.value)
 
             #download finished executions
             for cloud_execution in db.get_cloud_finished_executions(session):
                 repository_id = cloud_execution.repository_id
-                print(f"Downloading results for {repository_id}...")
+                logger.info(f"Downloading results for {repository_id}...")
                 result_path = os.path.join(CLOUD_RESULTS_FOLDER, str(repository_id))
                 client.download_results(repository_id, result_path)
                 db.update_cloud_execution_status(session, repository_id, db.CloudStatus.RESULTS_AVAILABLE.value)
@@ -185,17 +383,17 @@ def monitor_cloud_runs():
             for cloud_execution in db.get_cloud_failed_executions(session):
                 try:
                     repository_id = cloud_execution.repository_id
-                    print(f"Downloading results for {repository_id}...")
+                    logger.info(f"Downloading results for {repository_id}...")
                     result_path = os.path.join(CLOUD_RESULTS_FOLDER, str(repository_id))
                     client.download_results(repository_id, result_path, extensions=['log'])
                     db.update_cloud_execution_status(session, repository_id, db.CloudStatus.LOGS_AVAILABLE_ERROR.value)
                 except Exception as e:
-                    print(f"Error downloading results for {repository_id}: {e}")
-                    print("Forcing execution to Failed downloaded execution")
+                    logger.exception(f"Error downloading results for {repository_id}: {e}")
+                    logger.warning("Forcing execution to Failed downloaded execution")
                     db.update_cloud_execution_status(session, repository_id, db.CloudStatus.LOGS_AVAILABLE_ERROR.value)
                     continue
         else:
-            print("Database not initialized. Retrying in 30s...")
+            logger.info("Database not initialized. Retrying in 30s...")
         time.sleep(30)
 
 threading.Thread(target=monitor_cloud_runs, daemon=True).start()
@@ -224,7 +422,7 @@ def upload_file():
 @app.route('/run', methods=['POST'])
 def run_endpoint():
     global session
-    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    cloud_execution = request.values.get('cloud_execution', 'false').lower() == 'true'
     case_id = request.form.get('case_id')
 
     if not case_id:
@@ -234,6 +432,15 @@ def run_endpoint():
     if not os.path.exists(zip_case_path):
         return jsonify({'error': 'Upload file for this case ID not found'}), 404
 
+    # Pre-check: for each distinct module, if the last execution failed, block the run
+    failing_modules = []
+    for mname in db.get_distinct_module_names_for_case(session, case_id):
+        last = db.last_module_execution_for_case(session, case_id, mname)
+        if last and last.status == db.LOCAL_EXECUTION_ERROR:
+            failing_modules.append(mname)
+    if failing_modules:
+        return jsonify({'error': 'Case has failed modules in last execution', 'modules': failing_modules}), 409
+
     if cloud_execution:
         cloud_upload_id = str(ulid.ULID())
         _cloud_upload_queue.put((cloud_upload_id, case_id))
@@ -246,10 +453,40 @@ def run_endpoint():
         _execution_queue.put((execution_id, case_id))
 
         db.register_local_execution(session, case_id, execution_id)
+        # Mark as running explicitly
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_RUNNING)
 
         return jsonify({'case_id': case_id, 'execution_id': execution_id}), 200
 
 
+@app.route('/run_module', methods=['POST'])
+def run_module_endpoint():
+    global session
+    case_id = request.form.get('case_id')
+    module_name = request.form.get('module') or request.form.get('module_name')
+
+    if not case_id or not module_name:
+        return jsonify({'error': 'case_id and module are required'}), 400
+
+    # Validate case zip exists
+    zip_case_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    if not os.path.exists(zip_case_path) and not os.path.isdir(workdir):
+        return jsonify({'error': 'Upload file or working directory for this case ID not found'}), 404
+
+    # Validate module exists in config
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg or 'command' not in module_cfg:
+        return jsonify({'error': f"Module '{module_name}' not configured"}), 400
+
+    execution_id = str(ulid.ULID())
+    _execution_queue.put({'type': 'module', 'execution_id': execution_id, 'case_id': case_id, 'module': module_name})
+    db.register_local_execution(session, case_id, execution_id, is_module=1, module=module_name)
+    db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_RUNNING)
+
+    return jsonify({'case_id': case_id, 'module': module_name, 'execution_id': execution_id}), 200
+
+
 @app.route('/upload_and_run', methods=['POST'])
 def upload_and_run_file():
     global session
@@ -260,7 +497,7 @@ def upload_and_run_file():
     if file.filename == '':
         return jsonify({'error': 'No selected file'}), 400
     
-    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    cloud_execution = request.values.get('cloud_execution', 'false').lower() == 'true'
 
     case_id = str(ulid.ULID())
     zip_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
@@ -302,7 +539,7 @@ def get_status(execution_id):
     """
     global client
     global session
-    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    cloud_execution = request.values.get('cloud_execution', 'false').lower() == 'true'
 
     if cloud_execution:
         repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
@@ -321,7 +558,7 @@ def get_status(execution_id):
             status_msg = 'Execution finished with errors and log files are avaialble to download'
         else:
             status_msg = 'Unknown status'
-        print(f"Cloud execution status for {execution_id} ({repository_id}): {status_msg}")
+        logger.info(f"Cloud execution status for {execution_id} ({repository_id}): {status_msg}")
         return jsonify({'status_id': status, 'status_msg': status_msg}), 200
     else:
         status = db.get_local_execution_status(session, execution_id)
@@ -338,7 +575,8 @@ def get_status(execution_id):
 def get_results(execution_id: str):
     global session
     global client
-    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    cloud_execution = request.values.get('cloud_execution', 'false').lower() == 'true'
+    logger.info(f"Getting results for execution ID: {execution_id} (cloud_execution={cloud_execution})")
 
     if cloud_execution:
         repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
@@ -346,6 +584,7 @@ def get_results(execution_id: str):
             return jsonify({'error': 'Execution ID not found in Cloud'}),
         status = db.get_cloud_execution_status(session, execution_id)
 
+        
         if status == db.CloudStatus.RUNNING:
             return jsonify({'error': f'{repository_id} execution not finished yet'}), 402
         elif status == db.CloudStatus.FINISHED:
@@ -371,11 +610,47 @@ def get_results(execution_id: str):
     return jsonify({'execution_id': execution_id, 'files': result_files}), 200
 
 
+@app.route('/module_log/<case_id>', methods=['GET'])
+def get_module_log(case_id: str):
+    """Return the content of the module's fixed log file for the last module run of the case,
+    or for a specific module if provided as query parameter ?module=<name>.
+    """
+    global session
+    module_name = request.args.get('module') or request.args.get('module_name')
+
+    # Determine module and log file name
+    if not module_name:
+        last = db.last_module_execution_for_case(session, case_id)
+        if not last or not last.module:
+            return jsonify({'error': 'No module execution found for this case'}), 404
+        module_name = last.module
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg:
+        return jsonify({'error': f"Module '{module_name}' not configured"}), 400
+    log_name = module_cfg.get('log_file', f"module_{module_name}.log")
+
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    if not os.path.isdir(workdir):
+        # Ensure workdir is created (may extract zip if needed)
+        workdir = _ensure_case_workdir(case_id)
+    log_path = os.path.join(workdir, log_name)
+    if not os.path.exists(log_path):
+        return jsonify({'error': 'Log file not found', 'module': module_name, 'log': log_name}), 404
+
+    try:
+        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+        return content, 200, {'Content-Type': 'text/plain; charset=utf-8'}
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
 @app.route('/results/<execution_id>/<file>', methods=['GET'])
 def download_file(execution_id: str, file):
     global session
 
-    cloud_execution = request.form.get('cloud_execution', 'false').lower() == 'true'
+    cloud_execution = request.values.get('cloud_execution', 'false').lower() == 'true'
+    logger.info(f"Getting results for execution ID: {execution_id} (cloud_execution={cloud_execution})")
     
     if cloud_execution:
         repository_id = db.get_repository_id_from_cloud_upload_id(session, execution_id)
@@ -400,14 +675,15 @@ def download_file(execution_id: str, file):
 
 
 if __name__ == '__main__':
-    print("Starting server...")
+    logger.info("Starting server...")
     session = initialize_db()
+
     try:
-        app.run(debug=FLASK_DEBUG,
+        app.run(host=settings.get("host", DEFAULT_HOST), debug=FLASK_DEBUG,
                 port=settings.get("port", DEFAULT_PORT),
                 threaded=True,
                 use_reloader=False,)
     except Exception as e:
-        print(f"Error starting server: {e}")
+        logger.exception(f"Error starting server: {e}")
         sys.exit(1)
 

psr/execqueue/watcher.py

@@ -12,7 +12,7 @@ SERVER_URL = os.getenv("SERVER_URL", "http://127.0.0.1:5000")
 WATCH_DIR = os.getenv("WATCH_DIR")
 PROCESSED_DIR = os.getenv("PROCESSED_DIR")
 RESULTS_DIR = os.getenv("RESULTS_DIR", "results")
-SLEEP_SECONDS = int(os.getenv("WATCHER_SLEEP", "30"))
+SLEEP_SECONDS = int(os.getenv("WATCHER_SLEEP", "10"))
 DB_PATH = os.getenv("WATCHER_DB_PATH", "watcher.sqlite")
 
 

psr/factory/__init__.py

@@ -2,6 +2,6 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "5.0.0b21"
+__version__ = "5.0.0b67"
 
 from .api import *