[O2B-1125] Use scheduled process manager for synchronisation with MonALISA (#1340)

* instnatiate synchronzier

* typo

* use const instead of class property

Author: xsalonx

lib/application.js

@@ -14,11 +14,14 @@ const { Logger } = require('./utilities');
 const database = require('./database');
 const { webUiServer } = require('./server');
 const { gRPCServer } = require('./server/index.js');
-const { GRPCConfig } = require('./config');
+const { GRPCConfig, ServicesConfig } = require('./config');
+
+const { monalisa: monalisaConfig } = ServicesConfig;
 const { handleLostRunsAndEnvironments } = require('./server/services/housekeeping/handleLostRunsAndEnvironments.js');
-const { ServicesConfig } = require('./config/index.js');
 const { isInTestMode } = require('./utilities/env-utils.js');
 const { ScheduledProcessesManager } = require('./server/services/ScheduledProcessesManager.js');
+const { MonALISASynchronizer } = require('./server/monalisa-synchronization/MonALISASynchronizer');
+const { createMonALISAClient } = require('./server/monalisa-synchronization/MonALISAClient');
 
 /**
  * Bookkeeping Application
@@ -52,26 +55,20 @@ class BookkeepingApplication {
                 await this.gRPCServer.listen(gRPCOrigin);
             }
 
-            if (ServicesConfig.enableHousekeeping) {
+            if (monalisaConfig.enableSynchronization) {
+                const monALISASynchronizer = await this.createMonALISASynchronizer();
                 this.scheduledProcessesManager.schedule(
-                    async () => {
-                        try {
-                            const { transitionedEnvironments, endedRuns } = await handleLostRunsAndEnvironments();
-                            const subMessages = [];
-                            if (transitionedEnvironments.length > 0) {
-                                subMessages.push(`environments (${transitionedEnvironments.join(', ')})`);
-                            }
-                            if (endedRuns.length > 0) {
-                                subMessages.push(`runs (${endedRuns.join(', ')})`);
-                            }
-
-                            if (subMessages.length > 0) {
-                                this.logger.debug(`Updated lost ${subMessages.join(' and ')}`);
-                            }
-                        } catch (error) {
-                            this.logger.error(`Error while handling lost runs & environments: ${error}`);
-                        }
+                    () => monALISASynchronizer.synchronizeDataPassesFromMonALISA(),
+                    {
+                        wait: 10 * 1000,
+                        every: monalisaConfig.synchronizationPeriod,
                     },
+                );
+            }
+
+            if (ServicesConfig.enableHousekeeping) {
+                this.scheduledProcessesManager.schedule(
+                    () => this.housekeeping(),
                     {
                         wait: 30 * 1000,
                         every: 30 * 1000,
@@ -86,6 +83,43 @@ class BookkeepingApplication {
         this.logger.info('Started');
     }
 
+    /**
+     * Instantiate MonALISA synchronizer with global configuration
+     * @return {MonALISASynchronizer} instance
+     */
+    async createMonALISASynchronizer() {
+        return new MonALISASynchronizer(await createMonALISAClient({
+            dataPassesUrl: monalisaConfig.dataPassesUrl,
+            dataPassDetailsUrl: monalisaConfig.dataPassDetailsUrl,
+            yearLowerLimit: monalisaConfig.dataPassesYearLowerLimit,
+            userCertificatePath: monalisaConfig.userCertificate.path,
+            certificatePassphrase: monalisaConfig.userCertificate.passphrase,
+        }));
+    }
+
+    /**
+     * Houskeeping method, it wraps @see handleLostRunsAndEnvironments and logs its results
+     * @return {Promise<void>} promise
+     */
+    async housekeeping() {
+        try {
+            const { transitionedEnvironments, endedRuns } = await handleLostRunsAndEnvironments();
+            const subMessages = [];
+            if (transitionedEnvironments.length > 0) {
+                subMessages.push(`environments (${transitionedEnvironments.join(', ')})`);
+            }
+            if (endedRuns.length > 0) {
+                subMessages.push(`runs (${endedRuns.join(', ')})`);
+            }
+
+            if (subMessages.length > 0) {
+                this.logger.debug(`Updated lost ${subMessages.join(' and ')}`);
+            }
+        } catch (error) {
+            this.logger.error(`Error while handling lost runs & environments: ${error}`);
+        }
+    }
+
     /**
      * Begins the process of terminating the application. Calling this method terminates the process.
      *

lib/config/services.js

@@ -17,6 +17,8 @@ const {
     DATA_PASSES_YEAR_LOWER_LIMIT,
     MONALISA_DATA_PASSES_URL,
     MONALISA_DATA_PASS_DETAILS_URL,
+    MONALISA_ENABLE_SYNCHRONIZATION,
+    MONALISA_SYNCHRONIZATION_PERIODS,
 } = process.env ?? {};
 
 exports.services = {
@@ -46,5 +48,8 @@ exports.services = {
 
         dataPassesUrl: MONALISA_DATA_PASSES_URL,
         dataPassDetailsUrl: MONALISA_DATA_PASS_DETAILS_URL,
+
+        enableSynchronization: MONALISA_ENABLE_SYNCHRONIZATION?.toLowerCase() === 'true',
+        synchronizationPeriod: Number(MONALISA_SYNCHRONIZATION_PERIODS) || 3600000, //  1h in milisecond
     },
 };