ibmapm-restclient/lib/plugins/BAMPlugin.js

Node.js rest client for ICAM.

'use strict';
// # Config options (order)
// serverConfig (Highest)
// System properties (if applicable i.e JAVA)
// Environment variables
// Auto discover
// global.environment
// Bluemix VCAP (lowest)

var url = require('url');
var fs = require('fs');
var path = require('path');
var properties = require('properties');

var pluginConfig = require('../restclient/config.js').pluginConfig;
var k8sutil = require('../tools/k8sutil');
var sender = require('../restclient/sender-queue');
var rcutil = require('./util');
var logger = require('./logutil').getLogger('BAMPlugin.js');

var queue;
var MOUNT_PATH = '/opt/ibm/apm/serverconfig';
var mountPathGlobalEnv = path.join(MOUNT_PATH, 'global.environment');

var bamconns = {};
var app_guid;

// This connection is setted by env IBM_APM_SERVER_INGRESS_URL
var IBAM_options;
var providerPath = '?type=providers';
var aarPath = '?type=aar/middleware';
var adrPath = '?type=adr/middleware';
var gzipped = true;
var tId = pluginConfig.cfg.tenantID;
process.env.APM_TENANT_ID = tId;
var EventEmitter = require('events').EventEmitter;
var ready_event = new EventEmitter();
var initialized = false;
var WF_SVCS_CONN = {
    RESOURCEMGMT_SERVICE_BASE_PATH: process.env.RESOURCEMGMT_SERVICE_BASE_PATH ?
        rcutil.decBase64Ex(process.env.RESOURCEMGMT_SERVICE_BASE_PATH) :
        pluginConfig.globalEnv.RESOURCEMGMT_SERVICE_BASE_PATH || '/applicationmgmt/0.9',
    METRICS_SERVICE_BASE_PATH: process.env.METRICS_SERVICE_BASE_PATH ?
        rcutil.decBase64Ex(process.env.METRICS_SERVICE_BASE_PATH) :
        pluginConfig.globalEnv.METRICS_SERVICE_BASE_PATH || '/metric/1.0',
    UI_SERVICE_BASE_PATH: process.env.UI_SERVICE_BASE_PATH ?
        rcutil.decBase64Ex(process.env.UI_SERVICE_BASE_PATH) :
        pluginConfig.globalEnv.UI_SERVICE_BASE_PATH || '/uielement/0.8',
    AGENTMGMT_SERVICE_BASE_PATH: process.env.AGENTMGMT_SERVICE_BASE_PATH ?
        rcutil.decBase64Ex(process.env.AGENTMGMT_SERVICE_BASE_PATH) :
        pluginConfig.globalEnv.AGENTMGMT_SERVICE_BASE_PATH || '/agent_mgmt/0.6'
};

/* function concatTask(tasks) {
    var task = { payload: '' };

    var payloads = [];
    if (tasks.length > 0) {

        tasks.forEach(function(element) {
            task = element;
            if (Array.isArray(element.payload)) {
                payloads = payloads.concat(element.payload);
            } else {
                payloads.push(element.payload);
            }
        }, this);
        task.payload = payloads;
    }

    return task;
}*/

module.exports.Name = function() {
    return 'BAMPlugin';
};

module.exports.checkReadyStatus = function(callback) {
    logger.debug('checkReadyStatus()');
    if (callback) {
        ready_event.once('bam_initialized', function() {
            logger.debug('Got bam_initialized event');
            callback(initialized);
        });
    }
};
var metadataUploadTimestamp = 0;
var uiUploadTimestamp = 0;
module.exports.send = function(tasks) {

    if (!queue) {
        queue = sender.getQueue('bam');
    }
    for (let indext = 0; indext < tasks.length; indext++) {
        const task = tasks[indext];
        let payloads = [];
        if (Array.isArray(task.payload)) {
            payloads = payloads.concat(task.payload);
        } else if (task.payload !== undefined) {
            payloads.push(task.payload);
        } else {
            sendOne(task); // send a task without payload
        }
        if (task.type !== 'metrics: ') {
            if (task.type.indexOf('adr:') === 0 || task.type.indexOf('aar:') === 0) {
                sendOne(task);
            } else {
                for (let index = 0; payloads && index < payloads.length; index++) {
                    if (Array.isArray(payloads[index])) {
                        for (var i = 0; i < payloads[index].length; i++) {
                            var payload = payloads[index][i];
                            if (payload.BIOnly) {
                                continue; // ignore BI-only part
                            }

                            task.payload = payload;
                            sendOne(task);
                        }
                    } else {
                        if (!payloads[index].BIOnly) {
                            task.payload = payloads[index];
                            sendOne(task);
                        }
                    }
                }
            }
        } else if (payloads.length > 0) {
            var metricsPayload = [];
            for (let index = 0; payloads && index < payloads.length; index++) {
                if (payloads[index].BIOnly) {
                    continue;
                }
                metricsPayload.push(formatMetrics(payloads[index]));
            }
            task.payload = metricsPayload;
            sendOne(task);
        }
    }

    var curr = new Date();
    if (!global.META_ISSEND && curr - metadataUploadTimestamp > 120000) {
        metadataUploadTimestamp = curr;
        sendMetadata();
    }
    if (!global.UI_ISSEND && curr - uiUploadTimestamp > 120000) {
        uiUploadTimestamp = curr;
        postAMUI();
    }

};

function formatMetrics(payload) {
    if (payload.metrics && payload.metrics.requestErrorRate) {
        payload.metrics.requestErrorRate *= 100;
    }
    if (payload.metrics && payload.metrics.errorRate) {
        payload.metrics.errorRate *= 100;
    }
    if (payload.metrics && payload.metrics.loopCpuSystem) {
        payload.metrics.loopCpuSystem *= 100;
    }
    if (payload.metrics && payload.metrics.loopCpuUser) {
        payload.metrics.loopCpuUser *= 100;
    }
    return payload;
}

function sendOne(task) {
    if (task.empty) {
        queue.send(task);
        return;
    }
    logger.debug('BAMPlugin.sendOne', 'the type is ', task.type);
    dumpResourceIDs4Test(task.type, task.payload);

    if (!task.additionalHeader) {
        task.additionalHeader = {};
    }
    if (!task.addtionalOptions) {
        task.addtionalOptions = {};
    }
    if (IBAM_options) {
        var additionalHeader = task.additionalHeader;
        if (IBAM_options.headers) {
            for (let key in IBAM_options.headers) {
                additionalHeader[key] = additionalHeader[key] ? additionalHeader[key] :
                    IBAM_options.headers[key];
            }
        }
        var addtionalOptions = task.addtionalOptions;
        if (IBAM_options.addtionalOptions) {
            for (let key in IBAM_options.addtionalOptions) {
                task.addtionalOptions[key] = addtionalOptions[key] ? addtionalOptions[key] :
                    IBAM_options.addtionalOptions[key];
            }
        }
        // env IBAM_INGRESS_URL & IBAM_TOKEN are set
        let wf_url = process.env.IBAM_INGRESS_URL;
        let me = '&origin=' + global.KNJ_BAM_ORIGINID;
        if (task.type.indexOf('resources:') === 0) {
            task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/resources';
        }

        if (task.type.indexOf('updateResources:') === 0) {
            task.url = wf_url + task.location;
            task.PUT = true;
        }

        if (task.type && task.type.indexOf('metadata:') === 0) {
            task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/metadata';
        }

        if (task.type && task.type.indexOf('amui:') === 0) {
            task.url = wf_url +
                WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH +
                '/providers/uiconfiguration/bulk' + '?version=' + global.DC_VERSION;
            if (!(task.payload instanceof Buffer)) {
                task.payload = Buffer.from(task.payload);
            }
        }

        if (task.type && task.type.indexOf('dcconfig:') === 0) {
            if (process.env.UA_LWDC_LISTENER_URL) {
                task.url = process.env.UA_LWDC_LISTENER_URL + '/providers/configuration';
            } else {
                task.url = wf_url +
                    WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH + '/providers/configuration';
            }
        }
        if (task.type && task.type.indexOf('rteNotify:') === 0) {
            task.url = wf_url +
                WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH + '/notification?providerUniqueId=' + task.keyIndexName;
        }


        if (task.type && task.type.indexOf('situation:') === 0) {
            task.url = wf_url +
                WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH + '/providers/situation_configuration';
        }

        if (task.type.indexOf('queryDc:') === 0) {
            task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH +
                '/providers?_filter=keyIndexName=' + task.keyIndexName;
            task.GET = true;
            task.additionalHeader['Accept'] = 'application/json';
        }
        if (task.type.indexOf('queryK8MC:') === 0) {
            task.url = wf_url + '/api/v1/namespaces/' + task.namespace + '/configmaps/' + task.k8mc;
            task.GET = true;
            task.additionalHeader['Accept'] = 'application/json';
        }

        if (task.type.indexOf('queryResource:') === 0) {
            task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH +
                '/resources?_filter=uid=' + task.uid;
            task.GET = true;
        }
        if (task.type.indexOf('queryRelationship:') === 0) {
            task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH +
                '/resources/' + task.id + '/relationships';
            task.GET = true;
            task.additionalHeader['Accept'] = 'application/json';
        }

        if (task.type.indexOf('queryConfiguration:') === 0) {
            if (process.env.UA_LWDC_LISTENER_URL) {
                task.url = process.env.UA_LWDC_LISTENER_URL + '/providers/configuration?providerUniqueId=' +
                    task.keyIndexName;
            } else {
                task.url = wf_url +
                    WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH + '/providers/configuration?providerUniqueId=' +
                    task.keyIndexName;
            }
            task.GET = true;
            task.additionalHeader['Accept'] = 'application/json';
        }

        if (task.type.indexOf('metrics:') === 0) {
            if (process.env.UA_LWDC_LISTENER_URL) {
                task.url = process.env.UA_LWDC_LISTENER_URL + '/metric';
            } else {
                task.url = wf_url + WF_SVCS_CONN.METRICS_SERVICE_BASE_PATH + '/data';
            }
        }
        if (task.type.indexOf('aar:') === 0) {
            task.url = wf_url + aarPath + me;
        }
        if (task.type.indexOf('adr:') === 0) {
            task.url = wf_url + adrPath + me;
        }
        if (task.type.indexOf('dc:') === 0) {
            if (process.env.UA_LWDC_LISTENER_URL) {
                task.url = process.env.UA_LWDC_LISTENER_URL + '/providers';
            } else {
                task.url = wf_url + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/providers';
            }
        }

        logger.debug('BAMPlugin.sendOne', 'the task send to IBAM: ' + task.url);
        queue.send(task);
    }
    addQueue(task);

    return;
}

function addQueue(task) {
    for (let key in bamconns) {
        if (bamconns.hasOwnProperty(key)) {
            let element = bamconns[key];
            if (task.type.indexOf('resources:') === 0) {
                task.url = element.rms_resource_url;
            }
            if (task.type.indexOf('updateResources:') === 0) {
                task.url = element.server_url + task.location;
                task.PUT = true;
            }
            if (task.type && task.type.indexOf('metadata:') === 0) {
                task.url = element.rms_metadata_url;
            }
            if (task.type && task.type.indexOf('amui:') === 0) {
                task.url = element.ui_url + '?version=' + global.DC_VERSION;
                if (!(task.payload instanceof Buffer)) {
                    task.payload = Buffer.from(task.payload);
                }
            }
            if (task.type.indexOf('metrics:') === 0) {
                if (process.env.UA_LWDC_LISTENER_URL) {
                    task.url = process.env.UA_LWDC_LISTENER_URL + '/metric';
                } else {
                    task.url = element.metric_url;
                }
            }
            if (task.type.indexOf('aar:') === 0) {
                task.url = element.tt_url;
            }
            if (task.type.indexOf('adr:') === 0) {
                task.url = element.deepdive_url;
                task.gzipped = gzipped;
            }
            if (task.type.indexOf('dc:') === 0) {
                if (process.env.UA_LWDC_LISTENER_URL) {
                    task.url = process.env.UA_LWDC_LISTENER_URL + '/providers';
                } else {
                    task.url = element.rms_provider_url;
                }
            }
            if (task.type.indexOf('dcconfig:') === 0) {
                if (process.env.UA_LWDC_LISTENER_URL) {
                    task.url = process.env.UA_LWDC_LISTENER_URL + '/providers/configuration';
                } else {
                    task.url = element.agentmgmt_base_url + '/providers/configuration';
                }
            }
            if (task.type.indexOf('rteNotify:') === 0) {
                task.url = element.agentmgmt_base_url + '/notification?providerUniqueId=' + task.keyIndexName;
            }

            if (task.type.indexOf('situation:') === 0) {
                task.url = element.agentmgmt_base_url + '/providers/situation_configuration';
            }
            if (task.type.indexOf('queryDc:') === 0) {
                task.url = element.rms_provider_url + '?_filter=keyIndexName=' + task.keyIndexName;
                task.GET = true;
                task.additionalHeader['Accept'] = 'application/json';
            }
            if (task.type.indexOf('queryK8MC:') === 0) {
                task.url = element.server_url + '/api/v1/namespaces/' + task.namespace + '/configmaps/' + task.k8mc;
                task.GET = true;
                task.additionalHeader['Accept'] = 'application/json';
            }

            if (task.type.indexOf('queryResource:') === 0) {
                task.url = element.rms_resource_url + '?_filter=uid=' + task.uid;
                task.GET = true;
            }
            if (task.type.indexOf('queryRelationship:') === 0) {
                task.url = element.rms_resource_url + '/' + task.id + '/relationships';
                task.GET = true;
                task.additionalHeader['Accept'] = 'application/json';
            }

            if (task.type.indexOf('queryConfiguration:') === 0) { // TODO
                if (process.env.UA_LWDC_LISTENER_URL) {
                    task.url = process.env.UA_LWDC_LISTENER_URL + '/providers/configuration?providerUniqueId=' +
                        task.keyIndexName;
                } else {
                    task.url = element.agentmgmt_base_url + '/providers/configuration?providerUniqueId=' +
                        task.keyIndexName;
                }
                task.GET = true;
                task.additionalHeader['Accept'] = 'application/json';
            }


            if (element.pfx) {
                task.addtionalOptions.pfx = element.pfx;
                task.addtionalOptions.ca = element.pfx;
                task.addtionalOptions.requestCert = true;
            }

            if (element.keyfile_password) {
                task.addtionalOptions.passphrase = element.keyfile_password;
            }
            if (element.header) {
                for (key in element.header) {
                    if (!task.additionalHeader[key]) {
                        task.additionalHeader[key] = element.header[key];
                    }
                }
            }

            logger.debug('the task send to ' + task.url);

            queue.send(task);
        }
    }
}

var count = 1;
var intervalObj;
var intervalObjSec;
module.exports.stop = function() {
    logger.debug('Stop BAMPlugin.');
    if (intervalObj) {
        clearInterval(intervalObj);
    }
    if (intervalObjSec) {
        clearInterval(intervalObjSec);
    }
};

if (k8sutil.isICP()) {
    var controller = require('../tools/icpcontroller');
    var event = controller.getEvent();
    event.once('conn_ready_on_icp', initOnICP);
} else {
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 0: ',
        pluginConfig.globalEnv);
    init();
    logger.debug('Initialized from non-ICP environment.');
    intervalObj = setInterval(emitEvent, 10000);
    intervalObj.unref();
}

function emitEvent() {
    if (initialized) {
        logger.debug('Emit bam_initialized event. count = ', count, initialized);
        ready_event.emit('bam_initialized');
        if (count > 10) {
            clearInterval(intervalObj);
        }
        count++;
    }
}

function initOnICP(returnCode) {
    init();
    logger.debug('Initialized from ICP environment.', returnCode);
    intervalObj = setInterval(emitEvent, 10000);
    intervalObj.unref();
}

function init() {

    logger.debug('process.env.VCAP_APPLICATION', process.env.VCAP_APPLICATION);
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 1: ',
        pluginConfig.globalEnv);
    rcutil.init();
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 2: ',
        pluginConfig.globalEnv);
    setAppTenantID();
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 3: ',
        pluginConfig.globalEnv);
    parseIngressURL();
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 4: ',
        pluginConfig.globalEnv);
    setServerConn();
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 5: ',
        pluginConfig.globalEnv);
    logger.debug('BAMPlugin.js', 'init',
        'pluginConfig.globalEnv 6: ',
        pluginConfig.globalEnv);
    setServerConnGE();
}

function setServerConnGE() {
    logger.debug('BAMPlugin.js', 'setServerConnGE',
        'Retrive server configuration from global.environment.',
        process.env.IBM_APM_SERVER_INGRESS_URL);
    if (process.env.IBM_APM_SERVER_INGRESS_URL) {
        return;
    }
    logger.debug('BAMPlugin.js', 'setServerConnGE',
        'Retrive server configuration from global.environment.',
        pluginConfig.globalEnv);

    let bamurl = process.env.UA_LWDC_LISTENER_URL ?
        process.env.UA_LWDC_LISTENER_URL : pluginConfig.globalEnv.IBM_APM_SERVER_INGRESS_URL;
    var me = '&origin=' + global.KNJ_BAM_ORIGINID;
    if (bamurl &&
        isURL(bamurl)) {
        bamurl = bamurl.trim();
        bamconns[bamurl] = {
            server_url: bamurl,
            rms_resource_url: bamurl + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/resources',
            rms_provider_url: bamurl + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/providers',
            agentmgmt_base_url: bamurl + WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH,
            rms_metadata_url: bamurl + WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/metadata',
            metric_url: bamurl + WF_SVCS_CONN.METRICS_SERVICE_BASE_PATH + '/data',
            ui_url: bamurl + WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH +
                '/providers/uiconfiguration/bulk',
            tt_url: bamurl + aarPath + me,
            deepdive_url: bamurl + adrPath + me,
            dc_url: bamurl + providerPath + me
        };
        if (pluginConfig.globalEnv.ICAM_KEYFILE) {
            if (!pluginConfig.globalEnv.ICAM_KEYFILE.toLowerCase().endsWith('.p12')) {
                pluginConfig.globalEnv.ICAM_KEYFILE = pluginConfig.globalEnv.ICAM_KEYFILE + '.p12';
            }
            bamconns[bamurl].keyfile = pluginConfig.globalEnv.ICAM_KEYFILE;
            try {
                let buff;
                if (fs.existsSync(pluginConfig.globalEnv.ICAM_KEYFILE)) {
                    buff = fs.readFileSync(pluginConfig.globalEnv.ICAM_KEYFILE);
                } else {
                    buff = fs.readFileSync(__dirname + '/../../' + pluginConfig.globalEnv.ICAM_KEYFILE);
                }
                bamconns[bamurl].pfx = buff;
                bamconns[bamurl].ca = buff;
                bamconns[bamurl].requestCert = true;
            } catch (error) {
                logger.error('failed to read keyfile from local: ' + error);
            }
        }
        if (pluginConfig.globalEnv.ICAM_KEYFILE_PSWD) {
            bamconns[bamurl].keyfile_password = pluginConfig.globalEnv.ICAM_KEYFILE_PSWD;
        }

        bamconns[bamurl].header = {
            'X-TenantId': pluginConfig.globalEnv.APM_TENANT_ID ?
                pluginConfig.globalEnv.APM_TENANT_ID.trim() : tId,
            'BM-ApplicationId': app_guid,
            'Content-Type': 'application/json',
            Accept: 'application/json',
            'User-Agent': 'NodeDC'
        };

        if (pluginConfig.globalEnv.IBM_APM_ACCESS_TOKEN) {
            bamconns[bamurl].header['Authorization'] = 'Bearer ' + pluginConfig.globalEnv.IBM_APM_ACCESS_TOKEN;
        }
        initialized = true;
        logger.debug('BAMPlugin.js', 'setServerConnGE', bamconns[bamurl]);
    }

}

function setServerConn() {
    logger.debug('BAMPlugin.js', 'setServerConn',
        'Retrive server configuration from plugin configure file.');
    var https = require('https');
    var http = require('http');
    if (pluginConfig.plugins['BAM'] && pluginConfig.plugins['BAM'].connections) {

        var connections = pluginConfig.plugins['BAM'].connections;

        for (var index = 0; index < connections.length; index++) {
            var element = connections[index];
            if (!pluginConfig.isValidConn(element)) continue;
            var me = '&origin=' + global.KNJ_BAM_ORIGINID;
            bamconns[element.server_url] = {
                server_url: element.server_url,
                rms_resource_url: element.server_url +
                    WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/resources',
                rms_provider_url: element.server_url +
                    WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/providers',
                rms_metadata_url: element.server_url +
                    WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH + '/metadata',
                metric_url: element.server_url + WF_SVCS_CONN.METRICS_SERVICE_BASE_PATH + '/data',
                ui_url: element.server_url + WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH +
                    '/providers/uiconfiguration/bulk',
                tt_url: element.server_url + aarPath + me,
                deepdive_url: element.server_url + adrPath + me,
                dc_url: element.server_url + providerPath + me,
                keyfile: element.keyfile,
                keyfile_password: element.keyfile_password,
                proxy: element.proxy
            };
            initialized = true; // ready to send payload
            if (element.keyfile) {
                try {
                    let buff = fs.readFileSync(__dirname + '/../../' + element.keyfile);
                    bamconns[element.server_url].pfx = buff;
                    bamconns[element.server_url].ca = buff;
                    bamconns[element.server_url].requestCert = true;
                } catch (error) {
                    logger.error('failed to read keyfile from local: ' + error);
                }
            }

            if (element.keyfile_url) {
                var keyfile_options = url.parse(element.keyfile_url);
                rcutil.tlsFix8(keyfile_options);
                var sendmethod = (keyfile_options.protocol === 'http:' ? http : https);
                var bamconn = bamconns[element.server_url];
                let req = sendmethod.request(keyfile_options, function(res) {
                    res.on('data', function(d) {
                        if (!bamconn.pfx) {
                            bamconn.pfx = d;
                        } else {
                            bamconn.pfx = Buffer.concat([bamconn.pfx, d],
                                bamconn.pfx.length + d.length);
                        }
                        bamconn.ca = bamconn.pfx;
                        bamconn.requestCert = true;
                        bamconn.done = true;
                    });

                    res.on('error', function(error) {
                        logger.error('JsonSender response error: ', error);
                    });
                });
                req.on('error', function(error) {
                    logger.error('JsonSender request error: ', error);
                });
                req.end();
            }

            if (element.keyfile_password) {
                bamconns[element.server_url].passphrase = element.keyfile_password;
            }

            if (element.token) {
                bamconns[element.server_url].header = {
                    'X-TenantId': tId,
                    Authorization: 'Bearer ' + element.token,
                    'BM-ApplicationId': app_guid,
                    'Content-Type': 'application/json',
                    Accept: 'application/json',
                    'User-Agent': 'NodeDC'
                };
            }
        }
    }
}

function parseIngressURL() {
    logger.debug('Set the ingress url.',
        process.env.IBM_APM_SERVER_INGRESS_URL, process.env.IBM_APM_ACCESS_TOKEN);

    if (process.env.IBM_APM_SERVER_INGRESS_URL) {
        process.env.IBAM_INGRESS_URL = rcutil.decBase64Ex(process.env.IBM_APM_SERVER_INGRESS_URL);

    }
    if (k8sutil.isICP() && !process.env.IBAM_INGRESS_URL && k8sutil.getIngressUrl()) {
        process.env.IBAM_INGRESS_URL = k8sutil.getIngressUrl();
    }
    if (process.env.IBM_APM_ACCESS_TOKEN) {
        process.env.IBAM_TOKEN = rcutil.decBase64Ex(process.env.IBM_APM_ACCESS_TOKEN);
    }

    if (k8sutil.isICP() && !process.env.IBAM_INGRESS_URL && !process.env.UA_LWDC_LISTENER_URL) {
        intervalObjSec = setInterval(pollMountSecret, 60000);
        intervalObjSec.unref();
    }
    if (!process.env.IBAM_INGRESS_URL && process.env.UA_LWDC_LISTENER_URL) {
        process.env.IBAM_INGRESS_URL = process.env.UA_LWDC_LISTENER_URL;
    }
    if (process.env.IBAM_INGRESS_URL) {
        // check env IBAM_INGRESS_URL & IBAM_TOKEN, if these env are setted,
        // then send the data to it

        var header = {
            'X-TenantId': tId,
            'BM-ApplicationId': app_guid,
            'Content-Type': 'application/json',
            Accept: 'application/json',
            'User-Agent': 'NodeDC'
        };

        if (process.env.IBAM_TOKEN) {
            header.Authorization = 'Bearer ' + process.env.IBAM_TOKEN;
        }

        IBAM_options = {
            addtionalOptions: {},
            headers: header
        };
        if (process.env.ICAM_KEYFILE) {
            let keyfile = rcutil.decBase64Ex(process.env.ICAM_KEYFILE);
            if (!keyfile.toLowerCase().endsWith('.p12')) {
                keyfile = keyfile + '.p12';
            }
            try {
                let buff;
                if (fs.existsSync(keyfile)) {
                    buff = fs.readFileSync(keyfile);
                } else {
                    buff = fs.readFileSync(__dirname + '/../../' + keyfile);
                }
                IBAM_options.addtionalOptions.pfx = buff;
                IBAM_options.addtionalOptions.ca = buff;
                IBAM_options.addtionalOptions.requestCert = true;
            } catch (error) {
                logger.error('failed to read keyfile from local: ' + error);
            }
        }
        if (process.env.ICAM_KEYFILE_PSWD) {
            let keyfile_pwd = rcutil.decBase64Ex(process.env.ICAM_KEYFILE_PSWD);
            IBAM_options.addtionalOptions.passphrase = keyfile_pwd;
        }
        initialized = true; // ready to send payload
    }
}

function setAppTenantID() {
    app_guid = rcutil.getAppGuid();
    if (process.env.VCAP_APPLICATION) {
        var vcapApplication = JSON.parse(process.env.VCAP_APPLICATION);
        app_guid = vcapApplication['application_id'];
        if (!app_guid) {
            logger.error('Failed to get application_id from VCAP_APPLICATION. ');
            return;
        }

        // tId = vcapApplication['space_id'];
        // if (!tId) {
        //     logger.error('Failed to get space_id from VCAP_APPLICATION. ');
        //     return;
        // }
        logger.info('The application_id from VCAP_APPLICATION is ', app_guid);
        logger.info('The tenantID/space_id from VCAP_APPLICATION is ', tId);
    } else {
        logger.debug(' VCAP_APPLICATION env variable is not found.');
    }
}

function dumpResourceIDs4Test(type, payload) {
    if (process.env.DUMP_PROPERTIES_AVT) {
        let item = null;
        if (type === 'dc:' || type.substr(0, 'resources'.length) === 'resources') {
            if (payload.hasOwnProperty('uid') && payload.hasOwnProperty('entityTypes')) {
                let entityTypes = payload.entityTypes;
                if (entityTypes.length > 0) {
                    item = payload.uid + ':' + payload.entityTypes[0] + '\n';
                    let dumpBuffer = Buffer.from(item);
                    fs.writeFile('bam-avt-resource-list.properties',
                        dumpBuffer, {flag: 'a'},
                        function(err) {
                            if (err) {
                                logger.debug('Failed to dump resource id');
                            }
                            logger.debug('The resource id has been saved!');
                        });
                }
            }
        }
    }
}


function isURL(turl) {
    if (turl) {
        return turl.toLowerCase().startsWith('http');
    }
    return false;
}

function pollMountSecret() {
    logger.debug('in BAMPlugin pollMountSecret', mountPathGlobalEnv);
    // if (process.env.IBAM_INGRESS_URL) {
    //     clearInterval(intervalObjSec);
    //     return;
    // }
    let globalEnv;
    if (fs.existsSync(mountPathGlobalEnv)) {
        let globalCont = fs.readFileSync(mountPathGlobalEnv);
        globalEnv = properties.parse(globalCont.toString(), {
            separators: '=',
            comments: [';', '@', '#']
        });
        for (const key in globalEnv) {
            if (globalEnv.hasOwnProperty(key)) {
                const element = globalEnv[key];
                if (element.indexOf('@{') === 0) {
                    globalEnv[key] = undefined;
                    continue;
                }
                if (rcutil.isBase64(element)) {
                    globalEnv[key] = rcutil.decBase64(element);
                }
            }
        }
    } else {
        return;
    }

    logger.debug('Poll the server configure from mount folder:', mountPathGlobalEnv, globalEnv);
    if (globalEnv.AGENTMGMT_SERVICE_BASE_PATH) {
        WF_SVCS_CONN.AGENTMGMT_SERVICE_BASE_PATH = globalEnv.AGENTMGMT_SERVICE_BASE_PATH;
    }
    if (globalEnv.METRICS_SERVICE_BASE_PATH) {
        WF_SVCS_CONN.METRICS_SERVICE_BASE_PATH = globalEnv.METRICS_SERVICE_BASE_PATH;
    }
    if (globalEnv.RESOURCEMGMT_SERVICE_BASE_PATH) {
        WF_SVCS_CONN.RESOURCEMGMT_SERVICE_BASE_PATH = globalEnv.RESOURCEMGMT_SERVICE_BASE_PATH;
    }

    if (globalEnv.IBM_APM_SERVER_INGRESS_URL) {
        if (process.env.IBAM_INGRESS_URL && process.env.IBAM_INGRESS_URL === globalEnv.IBM_APM_SERVER_INGRESS_URL) {
            return;
        }
        process.env.IBAM_INGRESS_URL = globalEnv.IBM_APM_SERVER_INGRESS_URL;
        var header = {
            'X-TenantId': tId,
            'BM-ApplicationId': app_guid,
            'Content-Type': 'application/json',
            Accept: 'application/json',
            'User-Agent': 'NodeDC'
        };

        if (globalEnv.APM_TENANT_ID) {
            header['X-TenantId'] = globalEnv.APM_TENANT_ID;
            tId = globalEnv.APM_TENANT_ID;
            process.env.APM_TENANT_ID = tId;
        }

        if (globalEnv.IBM_APM_ACCESS_TOKEN) {
            header['Authorization'] = 'Bearer ' + globalEnv.IBM_APM_ACCESS_TOKEN;
        }
        IBAM_options = {
            addtionalOptions: {},
            headers: header
        };

        if (globalEnv.ICAM_KEYFILE) {
            if (!globalEnv.ICAM_KEYFILE.toLowerCase().endsWith('.p12')) {
                globalEnv.ICAM_KEYFILE = globalEnv.ICAM_KEYFILE + '.p12';
            }
            try {
                let buff;
                if (fs.existsSync(globalEnv.ICAM_KEYFILE)) {
                    buff = fs.readFileSync(globalEnv.ICAM_KEYFILE);
                } else if (fs.existsSync(path.join(MOUNT_PATH, globalEnv.ICAM_KEYFILE))) {
                    buff = fs.readFileSync(path.join(MOUNT_PATH, globalEnv.ICAM_KEYFILE));
                } else {
                    buff = fs.readFileSync(__dirname + '/../../' + globalEnv.ICAM_KEYFILE);
                }
                IBAM_options.addtionalOptions.pfx = buff;
                IBAM_options.addtionalOptions.ca = buff;
                IBAM_options.addtionalOptions.requestCert = true;
            } catch (error) {
                logger.error('failed to read keyfile from local: ' + error);
            }
        }
        if (globalEnv.ICAM_KEYFILE_PSWD) {
            IBAM_options.addtionalOptions.passphrase = globalEnv.ICAM_KEYFILE_PSWD;
        }

        if (globalEnv.JAEGER_ENDPOINT_ZIPKIN) {
            if (process.env.JAEGER_ENDPOINT_ZIPKIN &&
                process.env.JAEGER_ENDPOINT_ZIPKIN === globalEnv.JAEGER_ENDPOINT_ZIPKIN) {
                return;
            }
            process.env.JAEGER_ENDPOINT_ZIPKIN = globalEnv.JAEGER_ENDPOINT_ZIPKIN;
            if (process.env.JAEGER_ENDPOINT_ZIPKIN.startsWith('https')) {
                global.JAEGER_PFX = IBAM_options.addtionalOptions.pfx;
                global.JAEGER_PASSPHASE = IBAM_options.addtionalOptions.passphrase;
            }
        }
        if (globalEnv.JAEGER_ENDPOINT_ZIPKIN_V2) {
            if (process.env.JAEGER_ENDPOINT_ZIPKIN_V2 &&
                process.env.JAEGER_ENDPOINT_ZIPKIN_V2 === globalEnv.JAEGER_ENDPOINT_ZIPKIN_V2) {
                return;
            }
            process.env.JAEGER_ENDPOINT_ZIPKIN_V2 = globalEnv.JAEGER_ENDPOINT_ZIPKIN_V2;
            if (process.env.JAEGER_ENDPOINT_ZIPKIN_V2.startsWith('https')) {
                global.JAEGER_PFX = IBAM_options.addtionalOptions.pfx;
                global.JAEGER_PASSPHASE = IBAM_options.addtionalOptions.passphrase;
            }
        }

        initialized = true; // ready to send payload
        // clearInterval(intervalObjSec);
    }
}

function sendMetadata() {
    logger.debug('BAMPlugin.js', 'sendMetadata');
    if (!queue) {
        queue = sender.getQueue('bam');
    }

    let taskb = {
        type: 'metadata:',
        additionalHeader: {
            'X-TenantId': tId
        }
    };

    try {

        let mdruntime =
            require('../../etc/ResourceTypes/nodeApplicationRuntime_1.5_ResourceType.json');
        taskb['payload'] = JSON.stringify(mdruntime);
        taskb.callback = function(err, res) {
            if (err) {
                return;
            }
            if (res && (res.statusCode < 400 || res.statusCode === 409)) {
                global.META_ISSEND = true;
            }
        };
        queue.addTask(taskb);

    } catch (e) {
        logger.error(e);
    }
}

function postAMUI() {
    logger.debug('BAMPlugin.js', 'postAMUI');
    if (!queue) {
        queue = sender.getQueue('bam');
    }
    let task = {
        type: 'amui:',
        additionalHeader: {}
    };

    task.additionalHeader['Content-Type'] = 'application/zip';
    task.additionalHeader['X-TenantId'] = tId;
    let amui = path.join(__dirname, '/../../etc/AMUI/AMUI_kdn.zip');

    task['payload'] = amui;
    task.callback = function(err, res) {
        if (err) {
            return;
        }
        if (res && (res.statusCode < 400 || res.statusCode === 409)) {
            global.UI_ISSEND = true;
        }
    };
    queue.addTask(task);
    // queue.send(task);
}