[ACA-4227] [APS] Create a script to check Process Services Management plugin status before running e2e tests

lib/cli/scripts/plugins/aae-plugin.ts

@@ -0,0 +1,69 @@
+import { PluginInterface } from './plugin-model';
+import { logger } from '../logger';
+import { PluginConfiguration } from './plugin-config';
+
+export class ProcessAutomationPlugin {
+    config: PluginConfiguration;
+
+    constructor(
+        private plugInInfo: PluginInterface,
+        private alfrescoJsApi: any
+    ) {
+        this.config = new PluginConfiguration(
+            this.plugInInfo,
+            this.alfrescoJsApi,
+            true
+        );
+    }
+
+    async checkProcessServicesPlugin() {
+        try {
+            const isPluginEnabled = await this.config.isPluginEnabledFromAppConfiguration();
+            const isBackendActive = await this.checkBackendHealth();
+
+            if (isPluginEnabled && isBackendActive) {
+                logger.info(
+                    `The plugin ${
+                        this.plugInInfo.name
+                    } has been correctly configured`
+                );
+            } else {
+                this.logConfigurationError();
+                process.exit(1);
+            }
+        } catch (e) {
+            this.logConfigurationError(e);
+            process.exit(1);
+        }
+    }
+
+    async checkBackendHealth() {
+        const url = `${this.plugInInfo.host}/${this.plugInInfo.appName}/rb/actuator/health`;
+        let isBackendActive = true;
+        try {
+            const response = await this.config.callCustomApi(url);
+            if (response.status === 'UP') {
+                logger.info(`${this.plugInInfo.host} is UP!`);
+            } else {
+                logger.error(`${this.plugInInfo.host} is DOWN `);
+                isBackendActive = false;
+            }
+            return isBackendActive;
+        } catch (error) {
+            logger.error(
+                `${this.plugInInfo.host} is not reachable error: `,
+                error
+            );
+            return false;
+        }
+    }
+
+    private logConfigurationError(error?: any) {
+        logger.error(
+            `The plugin ${
+                this.plugInInfo.name
+            } has not been correctly configured`,
+            error
+        );
+    }
+}

lib/cli/scripts/plugins/aps-plugin.ts

@@ -0,0 +1,61 @@
+import { PluginInterface } from './plugin-model';
+import { logger } from '../logger';
+import { PluginConfiguration } from './plugin-config';
+
+export class ProcessServicePlugin {
+    config: PluginConfiguration;
+
+    constructor(private plugInInfo: PluginInterface, private alfrescoJsApi: any) {
+        this.config = new PluginConfiguration(this.plugInInfo, this.alfrescoJsApi, false);
+    }
+
+    async checkProcessServicesPlugin() {
+        try {
+            const isPluginEnabled = await this.config.isPluginEnabledFromAppConfiguration();
+            const isBackendActive = await this.checkBackendHealth();
+
+            if (isPluginEnabled && isBackendActive) {
+                logger.info(
+                    `The plugin ${
+                        this.plugInInfo.name
+                    } has been correctly configured`
+                );
+            } else {
+                this.logConfigurationError();
+                process.exit(1);
+            }
+        } catch (e) {
+            this.logConfigurationError(e);
+            process.exit(1);
+        }
+    }
+
+    async checkBackendHealth() {
+        try {
+            const systemProperties = await this.alfrescoJsApi.activiti.systemPropertiesApi.getProperties();
+            let isBackendActive = true;
+            if (systemProperties) {
+                logger.info(`${this.plugInInfo.host} is UP!`);
+            } else {
+                logger.error(`${this.plugInInfo.host} is DOWN `);
+                isBackendActive = false;
+            }
+            return isBackendActive;
+        } catch (error) {
+            logger.error(
+                `${this.plugInInfo.host} is not reachable error: `,
+                error
+            );
+            return false;
+        }
+    }
+
+    private logConfigurationError(error?: any) {
+        logger.error(
+            `The plugin ${
+                this.plugInInfo.name
+            } has not been correctly configured`,
+            error
+        );
+    }
+}

lib/cli/scripts/plugins/check-env.ts

@@ -0,0 +1,58 @@
+import { logger } from './../logger';
+import alfrescoApi = require('@alfresco/js-api');
+
+export class CheckEnv {
+    _alfrescoJsApi: any;
+    TIMEOUT = 6000;
+    MAX_RETRY = 10;
+    counter = 0;
+
+    constructor(
+        private host: string,
+        private username: string,
+        private password: string
+    ) {}
+
+    async checkEnv() {
+        try {
+            this.alfrescoJsApi = new alfrescoApi.AlfrescoApiCompatibility(<any> {
+                provider: 'ALL',
+                hostBpm: this.host,
+                hostEcm: this.host,
+                authType: 'OAUTH',
+                oauth2: {
+                    host: `${this.host}/auth/realms/alfresco`,
+                    clientId: 'alfresco',
+                    scope: 'openid'
+                }
+            });
+            await this.alfrescoJsApi.login(this.username, this.password);
+        } catch (e) {
+            logger.error('Login error environment down or inaccessible');
+            this.counter++;
+            if (this.MAX_RETRY === this.counter) {
+                logger.error('Give up');
+                process.exit(1);
+            } else {
+                logger.error(
+                    `Retry in 1 minute at main();tempt N ${this.counter}`
+                );
+                this.sleep(this.TIMEOUT);
+                this.checkEnv();
+            }
+        }
+    }
+
+    public get alfrescoJsApi() {
+        return this._alfrescoJsApi;
+    }
+
+    public set alfrescoJsApi(alfrescoJsApi: any) {
+        this._alfrescoJsApi = alfrescoJsApi;
+    }
+
+    sleep(delay) {
+        const start = new Date().getTime();
+        while (new Date().getTime() < start + delay) {}
+    }
+}

lib/cli/scripts/plugins/check-plugin-env.ts

@@ -0,0 +1,58 @@
+import { ProcessServicePlugin } from './aps-plugin';
+import { PluginTarget } from './plugin-model';
+import { CheckEnv } from './check-env';
+import program = require('commander');
+import { ProcessAutomationPlugin } from './aae-plugin';
+
+let pluginEnv;
+
+async function main() {
+    program
+        .version('0.1.0')
+        .option('--host [type]', 'Remote environment host')
+        .option('--pluginName [type]', 'pluginName ')
+        .option('--appName [type]', 'appName ')
+        .option('-p, --password [type]', 'password ')
+        .option('-u, --username [type]', 'username ')
+        .option('--ui, --uiName [type]', 'uiName')
+        .parse(process.argv);
+
+    pluginEnv = new CheckEnv(program.host, program.username, program.password);
+    await pluginEnv.checkEnv();
+
+    if (program.pluginName === PluginTarget.processService) {
+        checkProcessServicesPlugin();
+    }
+
+    if (program.pluginName === PluginTarget.processAutomation) {
+        checkProcessAutomationPlugin();
+    }
+}
+
+async function checkProcessServicesPlugin() {
+    const processServicePlugin = new ProcessServicePlugin(
+        {
+            host: program.host,
+            name: PluginTarget.processService,
+            appName: null,
+            uiName: null
+        },
+        pluginEnv.alfrescoJsApi
+    );
+    await processServicePlugin.checkProcessServicesPlugin();
+}
+
+async function checkProcessAutomationPlugin() {
+    const processServicePlugin = new ProcessAutomationPlugin(
+        {
+            host: program.host,
+            name: PluginTarget.processAutomation,
+            appName: program.appName,
+            uiName: program.uiName
+        },
+        pluginEnv.alfrescoJsApi
+    );
+    await processServicePlugin.checkProcessServicesPlugin();
+}
+
+main();

lib/cli/scripts/plugins/plugin-config.ts

@@ -0,0 +1,78 @@
+import { PluginInterface } from './plugin-model';
+import { logger } from '../logger';
+
+export class PluginConfiguration {
+    constructor(
+        private plugInInfo: PluginInterface,
+        private alfrescoJsApi: any,
+        private isProcessAutomation: boolean
+    ) {
+        this.plugInInfo = plugInInfo;
+        this.alfrescoJsApi = alfrescoJsApi;
+    }
+
+    async isPluginEnabledFromAppConfiguration() {
+        try {
+            const appConfig = await this.getAppConfig();
+            let isEnabled = true;
+            if (appConfig && appConfig.plugins[this.plugInInfo.name]) {
+                logger.info(
+                    `${
+                        this.plugInInfo.name
+                    } plugin is configured in app.config.json`
+                );
+            } else {
+                logger.error(
+                    `${
+                        this.plugInInfo.name
+                    } plugin is not configured in app.config.json`
+                );
+                return (isEnabled = false);
+            }
+
+            return isEnabled;
+        } catch (error) {
+            logger.error(
+                `${this.plugInInfo.host} is not reachable error: `,
+                error
+            );
+            return false;
+        }
+    }
+
+    async getAppConfig() {
+        const url = this.isProcessAutomation ? `${this.plugInInfo.host}/${this.plugInInfo.appName}/ui/${this.plugInInfo.uiName}/app.config.json` : `${this.plugInInfo.host}/app.config.json`;
+        return this.callCustomApi(url);
+    }
+
+    async callCustomApi(url: string) {
+        const pathParams = {},
+            headerParams = {},
+            formParams = {},
+            bodyParam = {},
+            queryParams = {},
+            contentTypes = ['application/json'],
+            accepts = ['application/json'];
+        try {
+            const response = await this.alfrescoJsApi.oauth2Auth.callCustomApi(
+                url,
+                'GET',
+                pathParams,
+                queryParams,
+                headerParams,
+                formParams,
+                bodyParam,
+                contentTypes,
+                accepts
+            );
+
+            return response;
+        } catch (error) {
+            logger.error(
+                `${this.plugInInfo.host} is not reachable error: `,
+                error
+            );
+            return {};
+        }
+    }
+}

lib/cli/scripts/plugins/plugin-model.ts

@@ -0,0 +1,12 @@
+export enum PluginTarget {
+    processService = 'processService',
+    processAutomation = 'processAutomation',
+    governance = 'governance'
+}
+
+export interface PluginInterface {
+    name: string;
+    host: string;
+    appName: string;
+    uiName: string;
+}