Closing RPE app in Windows leaves the backend server running in some instances causing clashes on new rpe instance

.github/workflows/rpe_test.yml

@@ -103,7 +103,13 @@ jobs:
         if: matrix.os == 'ubuntu-latest'  &&  always()
         run: find $HOME -type f -name "rpe.log" -exec cat {} +
 
-
+      - name: E2E Playwright shut down test on Linux latest
+        if: ${{ matrix.os == 'ubuntu-latest' }}     
+        run: |
+              rm -rf $HOME/rpe.log && xvfb-run --auto-servernum --server-args="-screen 0 1280x960x24" -- npx playwright test -- restart.test.js
+              cat $HOME/rpe.log | tail -n 2 | grep "Shutting down server..."
+              [[ $? != 0 ]] && exit 1
+
       - name: Run ESLint only on ubuntu-latest
         if: ${{ matrix.os == 'ubuntu-latest' }}
         run: npx eslint src/

backend/api/shutdown.py

@@ -0,0 +1,32 @@
+import signal
+import sys
+from flask import Blueprint, request, jsonify
+from submodule.rs_logger import log
+
+shutdown_api = Blueprint('shutdown_api', __name__)
+
+def shutdown_server():
+    """Function to gracefully shut down the server."""
+    log("Shutting down server...")
+    func = request.environ.get('werkzeug.server.shutdown')
+    if func is not None:
+        func()
+    else:
+        log("Server shutdown function not found.", level="ERROR")
+    sys.exit(0)
+
+def signal_handler(signal_received, frame):
+    """Handles signals for graceful shutdown."""
+    log(f"Signal {signal_received} received, initiating shutdown...")
+    shutdown_server()
+
+@shutdown_api.route('/shutdown', methods=['POST'])
+def trigger_shutdown():
+    """API endpoint to trigger a server shutdown."""
+    log("Shutdown API called by user request.")
+    shutdown_server()
+    return jsonify({"message": "Server is shutting down..."}), 200
+
+# Register the signal handler for SIGINT and SIGTERM
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)

backend/restapi_server.py

@@ -5,7 +5,7 @@
 import argparse
 import os
 import sys
-from flask import Flask, request, jsonify
+from flask import Flask, request
 from flasgger import Swagger
 from submodule.rs_device_manager import RsDeviceManager
 from submodule.rs_logger import log_setup, log, RsLogLevel
@@ -18,73 +18,72 @@
 from api.peripherals import peripherals_api
 from api.utils import attrs_api
 from api.project import project_api
+from api.shutdown import shutdown_api  #shutdown api
+
+# Create Flask app
+app = Flask(__name__)
+app.url_map.strict_slashes = False
+
+# Set up Swagger for API documentation
+swagger_template = {
+    "swagger": "2.0",
+    "info": {
+        "title": "RPE Backend API",
+        "description": "The RPE Backend APIs which consumed by the RPE frontend for power and thermal estimation of the Rapid Silicon devices.",
+        "version": "0.1.0"
+    }
+}
+swagger = Swagger(app, template=swagger_template)
+
+# Register API blueprints with the Flask app
+app.register_blueprint(device_api)
+app.register_blueprint(clock_api)
+app.register_blueprint(dsp_api)
+app.register_blueprint(fabric_le_api)
+app.register_blueprint(bram_api)
+app.register_blueprint(io_api)
+app.register_blueprint(peripherals_api)
+app.register_blueprint(attrs_api)
+app.register_blueprint(project_api)
+app.register_blueprint(shutdown_api)  # Register shutdown API
+
+# Hook up request signal to log requests by UI
+@app.before_request
+def before_request():
+    log(f"{request.method} {request.url}")
+
+@app.after_request
+def after_request(response):
+    log(f"{request.method} {request.url} {response.status_code} - DONE")
+    return response
 
-#
-# Main entry point
-#
 def main():
-    # create and parse command line args
-    parser = argparse.ArgumentParser(description='Rapid Power Estimator Rest API Server command-line arguments.')
-    parser.add_argument('device_file', type=str, help='Path to the input device xml file')
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description='Rapid Power Estimator REST API Server command-line arguments.')
+    parser.add_argument('device_file', type=str, help='Path to the input device XML file')
     parser.add_argument('--port', type=int, default=5000, help='Specify TCP Port to use for REST server')
     parser.add_argument('--debug', default=False, action='store_true', help='Enable/Disable debug mode')
     parser.add_argument('--logfile', type=str, default="rpe.log", help='Specify log file name')
-    parser.add_argument('--maxbytes', type=int, default=2048, help='Specify maximun log file size in kilobytes before rollover')
-    parser.add_argument('--backupcount', type=int, default=20, help='Specify no. of backup log files')
+    parser.add_argument('--maxbytes', type=int, default=2048, help='Specify maximum log file size in kilobytes before rollover')
+    parser.add_argument('--backupcount', type=int, default=20, help='Specify number of backup log files')
     args = parser.parse_args()
 
-    # setup app logger
-    log_setup(filename=args.logfile, max_bytes=args.maxbytes*1024, backup_count=args.backupcount)
+    # Set up logger
+    log_setup(filename=args.logfile, max_bytes=args.maxbytes * 1024, backup_count=args.backupcount)
 
     # Check if the device_file exists
-    if os.path.exists(args.device_file) == False:
+    if not os.path.exists(args.device_file):
         log(f"Device file '{args.device_file}' does not exist.", RsLogLevel.ERROR)
         sys.exit(1)
 
     # Parse Device XML file into Device List
     devicemanager = RsDeviceManager.get_instance()
     devicemanager.load_xml(args.device_file)
 
-    # create flask app object
-    app = Flask(__name__)
-    app.url_map.strict_slashes = False
-
-    # auto generate restapi documentation
-    template = {
-        "swagger": "2.0",
-        "info": {
-            "title": "RPE Backend API",
-            "description": "The RPE Backend APIs which consumed by the RPE frontend for power and thermal estimation of the Rapid Silicon devices.",
-            "version": "0.1.0"
-        }
-    }
-    swagger = Swagger(app, template=template)
-
-    # bind device api objects onto the flask app
-    app.register_blueprint(device_api)
-    app.register_blueprint(clock_api)
-    app.register_blueprint(dsp_api)
-    app.register_blueprint(fabric_le_api)
-    app.register_blueprint(bram_api)
-    app.register_blueprint(io_api)
-    app.register_blueprint(peripherals_api)
-    app.register_blueprint(attrs_api)
-    app.register_blueprint(project_api)
-
-    # hook up request signal to log request by UI
-    @app.before_request
-    def before_request():
-        log(f"{request.method} {request.url}")
-
-    @app.after_request
-    def after_request(response):
-        log(f"{request.method} {request.url} {response.status_code} - DONE")
-        return response
-
-    # log app server started
+    # Log server start message
     log("App server is running...")
 
-    # Start Rest API server
+    # Start the Flask app
     app.run(debug=args.debug, port=args.port)
 
 if __name__ == "__main__":

cleanup.js

@@ -1,6 +1,16 @@
+const { shutdown } = require('./src/utils/serverAPI');
 const isWindows = process.platform === 'win32';
 
-const kill = (process) => {
+const kill = async (process) => {
+  try {
+    // calling the shutdown API
+    await shutdown();
+    console.log('Shutdown API called successfully.');
+  } catch (error) {
+    console.error('Error calling shutdown API:', error);
+  }
+
+  // Fallback if API fails or for local process termination
   if (isWindows) {
     const kill = require('tree-kill');
     kill(process.pid);

main.js

@@ -190,7 +190,14 @@ const template = [
         },
       },
       { type: 'separator' },
-      { role: 'quit' },
+      //{ role: 'quit' },
+      {
+        label: 'Exit',
+        click: () => {
+          kill(serverProcess);  // just making sure shutdown api is called
+          app.quit();  // close the application
+        },
+      },
     ],
   },
   // {

src/utils/serverAPI.js

@@ -1,32 +1,47 @@
 const config = require('../../rpe.config.json');
-
 const { server } = config;
 let { port } = config;
 
-export function devices() { return `${server}:${port}/devices`; }
-export function attributes() { return `${server}:${port}/attributes`; }
-export function project() { return `${server}:${port}/project`; }
-export function projectClose() { return `${project()}/close`; }
-export function projectOpen() { return `${project()}/open`; }
-export function projectSave() { return `${project()}/create`; }
+function devices() {
+  return `${server}:${port}/devices`;
+}
+
+function attributes() {
+  return `${server}:${port}/attributes`;
+}
+
+function project() {
+  return `${server}:${port}/project`;
+}
+
+function projectClose() {
+  return `${project()}/close`;
+}
+
+function projectOpen() {
+  return `${project()}/open`;
+}
+
+function projectSave() {
+  return `${project()}/create`;
+}
 
-export function setPort(p, fetchDevices) {
+function setPort(p, fetchDevices) {
   if (p !== undefined) {
     port = p;
-    // eslint-disable-next-line no-use-before-define
     GET(devices(), fetchDevices);
   }
 }
 
-export function peripheralPath(deviceId, url) {
+function peripheralPath(deviceId, url) {
   return `${devices()}/${deviceId}/peripherals/${url}`;
 }
 
-export function deviceInfo(deviceId) {
+function deviceInfo(deviceId) {
   return `${devices()}/${deviceId}`;
 }
 
-export const Elem = {
+const Elem = {
   clocking: 'clocking',
   io: 'io',
   bram: 'bram',
@@ -35,7 +50,7 @@
   peripherals: 'peripherals',
 };
 
-export const api = {
+const api = {
   fetch(func, deviceId) {
     return `${devices()}/${deviceId}/${func}`;
   },
@@ -49,46 +64,64 @@
   },
 };
 
-export function POST(url, data, callback) {
+function POST(url, data, callback) {
   fetch(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(data),
   }).then((response) => {
-    if (response.ok) {
-      if (callback) callback();
-    }
+    if (response.ok && callback) callback();
   });
 }
 
-export function DELETE(url, callback) {
+function DELETE(url, callback) {
   fetch(url, {
     method: 'DELETE',
   }).then((response) => {
-    if (response.ok) {
-      if (callback) callback();
-    }
+    if (response.ok && callback) callback();
   });
 }
 
-export function PATCH(url, data, callback) {
+function PATCH(url, data, callback) {
   fetch(url, {
     method: 'PATCH',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(data),
   }).then((response) => {
-    if (response.ok) {
-      if (callback) callback();
-    } else {
-      // todo handle error
-    }
+    if (response.ok && callback) callback();
   });
 }
 
-export function GET(url, callback) {
+function GET(url, callback) {
   fetch(url)
     .then((response) => response.json())
     .then((data) => {
       if (callback) callback(data);
     });
 }
+
+// Function to call the shutdown API
+function shutdown(callback) {
+  const shutdownUrl = `${server}:${port}/shutdown`;
+  POST(shutdownUrl, null, callback);
+}
+
+// Exporting functions using CommonJS syntax
+module.exports = {
+  devices,
+  attributes,
+  project,
+  projectClose,
+  projectOpen,
+  projectSave,
+  setPort,
+  peripheralPath,
+  deviceInfo,
+  Elem,
+  api,
+  POST,
+  DELETE,
+  PATCH,
+  GET,
+  shutdown,
+};