wsinstance/index.js

//модуль для клиента
'use strict';
// это клиент

// Зависимости
let app = require('express')();
let timestamp = require('time-stamp');
let ip = require('ip');
let nanoid = require('nanoid');
let axios = require('axios');
const bodyParser   = require('body-parser');
const jwt        = require('jsonwebtoken');

// Конфигурация
const wsName = require('../../package.json').name;
const wsVersion = require('../../package.json').version;

let systemShortName = null;
let systemId = null;


let apigwPath = null;
let tokenForReq = null;
let globalApiGwPath = '';

const instanceID = nanoid.nanoid(10);


// Чтение body и cookie
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true}));
//app.use(cookieParser());


//let systemName = jwt.decode(wsCoreKey, {complete: true}).payload.systemName;

// Характеристики инстанса в сессии сокет-соединения
let socketToGlobalProvider = null;
let socketToGlobalApiGwBS = null;

let awaitedRequests = [];

function setGlobalApiGwPath(data){
    globalApiGwPath = data.globalApiGwPath.pathForRequests;
    tokenForReq =  data.globalApiGwPath.tokenForReq;
}

function checkGlobalApiGwPath(){
    return globalApiGwPath !== '';
}

function clearGlobalApiGwPath(){
    socketToGlobalApiGwBS.close()
    globalApiGwPath = '';
}

// функция для общего логирования
function msLog(logString, mark) {
    const msMark = mark || 'ok' ;
    console.log(`${timestamp('[DD-MM-YYYY HH:mm:ss.ms]')}: (${msMark}) ${logString}` )
}

// Проверка токена и соответствие запрашиваемого метода (типа\имени) токену
function checkReceivedTokenForReq(req){
    let isValid = null;
    jwt.verify(req.headers.tokenforreq, instanceID, function (err, decoded) {
        if (err) {
            msLog(`signedJWT не валидный(истек срок действия или внесены изменения)`, 'err');
            isValid = false;
        }
        else {
            isValid = (req._parsedUrl.pathname === `/${decoded.toMethodName}`) && (req.method === decoded.toMethodType);
        }
    });
    return isValid
}

// Проверка что запрос пришел санкционировано
app.use(function(req, res, next){
    if (req.method ==='OPTIONS'){
        next();
    }
    else {
        if ((['GET', 'POST', 'PUT', 'DELETE'].includes(req.method)) &&  ( checkReceivedTokenForReq(req) === true )){
            next();
        } else {
            msLog(`Ошибка обращения к сервису ${wsName}`, 'wrn');
            return res.send({result: 'error', reason: `Ошибка обращения к сервису ${wsName}`})
        }
    }
});

async function get (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'GET'});
    next = (function() {
        let cached_function = next;
        return async function() {
            const reqId = arguments[0].query.s_reqId || arguments[0].query.u_reqId || 'none';
            msLog(`Начало обработки GET запроса ${name} с идентификатором ${reqId}`, 'info');
            await cached_function.apply(this, arguments); // use .apply() to call it
            //console.log(arguments[0].query.u_reqId);
            msLog(`Завершение обработки GET запроса ${name} с идентификатором ${reqId}`, 'info');
        };
    }());
    app.get(name, next)
}

async function post (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'POST'});
    next = (function() {
        let cached_function = next;
        return async function() {
            const reqId = arguments[0].body.s_reqId || arguments[0].body.u_reqId || 'none';
            msLog(`Начало обработки POST запроса ${name} с идентификатором ${reqId}`, 'info');
            await cached_function.apply(this, arguments); // use .apply() to call it
            //console.log(arguments[0].query.u_reqId);
            msLog(`Завершение обработки POST запроса ${name} с идентификатором ${reqId}`, 'info');
        };
    }());
    app.post(name, next)
}
async function put (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'PUT'});
    next = (function() {
        let cached_function = next;
        return async function() {
            const reqId = arguments[0].body.s_reqId || arguments[0].body.u_reqId || 'none';
            msLog(`Начало обработки PUT запроса ${name} с идентификатором ${reqId}`, 'info');
            await cached_function.apply(this, arguments); // use .apply() to call it
            //console.log(arguments[0].query.u_reqId);
            msLog(`Завершение обработки PUT запроса ${name} с идентификатором ${reqId}`, 'info');
        };
    }());
    app.put(name, next)
}
async function del (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'DELETE'});
    next = (function() {
        let cached_function = next;
        return async function() {
            const reqId = arguments[0].query.s_reqId || arguments[0].query.u_reqId || 'none';
            msLog(`Начало обработки DELETE запроса ${name} с идентификатором ${reqId}`, 'info');
            await cached_function.apply(this, arguments); // use .apply() to call it
            //console.log(arguments[0].query.u_reqId);
            msLog(`Завершение обработки DELETE запроса ${name} с идентификатором ${reqId}`, 'info');
        };
    }());
    app.delete(name, next)
}

async function callGet (wsNameAndMethod, axiParams ) {
    const parsedReq = wsNameAndMethod.split('/');
    if (parsedReq.length !== 3){
        msLog(`Некорректное имя GET запроса ${wsNameAndMethod} (система/серис/метод)`, 'wrn');
        return {result: 'error', reason: `Некорректное имя GET запроса ${wsNameAndMethod} (система/серис/метод)`}
    }

    const s_reqId = 's_'+ nanoid.nanoid(6);
    if (!axiParams) {
        axiParams = {
            s_reqId:s_reqId
        }
    } else {
        axiParams.s_reqId = s_reqId;
    }

    // Обращаемся к global_apigw_bs за актуальным адресом инстанса запрашиваемого сервиса и токен для запроса
    const getParamsForReq = await axios.get(`${globalApiGwPath}/getParamsForReq`, {params: {methodType: 'GET', wsNameAndMethod: wsNameAndMethod}, headers: {tokenforreq: tokenForReq}}); //tokenForReq
    if (getParamsForReq.data.result === 'error'){
        return (getParamsForReq.data)
    }
    //console.log(getParamsForReq.data.data);
    //const axiosRes = await axios.get(`${globalApiGwPath.pathForRequests}/${methodName}`, {params:axiParams, headers: {systemtoken:'sometmptoken', fromsystemname:'global_healthws'}});
    const fullPath = getParamsForReq.data.data.pathForReq;
    const tokenForReq2 = getParamsForReq.data.data.onceTokenForReq;
    msLog(`Инициирован вызов межсервисного GET запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    //let fullPath = `${apigwPath}/${wsNameAndMethod}`;

    const axiosRes = await axios.get(`${fullPath}/${parsedReq[2]}`, {params:axiParams, headers: {tokenforreq: tokenForReq2}});
    msLog(`Получен ответ от межсервисного GET запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    return axiosRes.data
}

async function callPost (wsNameAndMethod, axiParams ) {
    const parsedReq = wsNameAndMethod.split('/');
    if (parsedReq.length !== 3){
        msLog(`Некорректное имя POST запроса ${wsNameAndMethod} (система/серис/метод)`, 'wrn');
        return {result: 'error', reason: `Некорректное имя POST запроса ${wsNameAndMethod} (система/серис/метод)`}
    }

    const s_reqId = 's_'+ nanoid.nanoid(6);
    if (!axiParams) {
        axiParams = {
            s_reqId:s_reqId
        }
    } else {
        axiParams.s_reqId = s_reqId;
    }

    // Обращаемся к global_apigw_bs за актуальным адресом инстанса запрашиваемого сервиса и токен для запроса
    const getParamsForReq = await axios.get(`${globalApiGwPath}/getParamsForReq`, {params: {methodType: 'POST', wsNameAndMethod: wsNameAndMethod}, headers: {tokenforreq: tokenForReq}}); //tokenForReq
    if (getParamsForReq.data.result === 'error'){
        return (getParamsForReq.data)
    }
    //console.log(getParamsForReq.data.data);
    //const axiosRes = await axios.get(`${globalApiGwPath.pathForRequests}/${methodName}`, {params:axiParams, headers: {systemtoken:'sometmptoken', fromsystemname:'global_healthws'}});
    const fullPath = getParamsForReq.data.data.pathForReq;
    const tokenForReq2 = getParamsForReq.data.data.onceTokenForReq;
    msLog(`Инициирован вызов межсервисного POST запросf ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    // let fullPath = `${apigwPath}/${wsNameAndMethod}`;

    const axiosRes = await axios.post(`${fullPath}/${parsedReq[2]}`, axiParams, {headers: {tokenforreq:tokenForReq2}});
    msLog(`Получен ответ от межсервисного POST запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    return axiosRes.data
}

async function callPut (wsNameAndMethod, axiParams ) {
    const parsedReq = wsNameAndMethod.split('/');
    if (parsedReq.length !== 3){
        msLog(`Некорректное имя PUT запроса ${wsNameAndMethod} (система/серис/метод)`, 'wrn');
        return {result: 'error', reason: `Некорректное имя PUT запроса ${wsNameAndMethod} (система/серис/метод)`}
    }

    const s_reqId = 's_'+ nanoid.nanoid(6);
    if (!axiParams) {
        axiParams = {
            s_reqId:s_reqId
        }
    } else {
        axiParams.s_reqId = s_reqId;
    }

    // Обращаемся к global_apigw_bs за актуальным адресом инстанса запрашиваемого сервиса и токен для запроса
    const getParamsForReq = await axios.get(`${globalApiGwPath}/getParamsForReq`, {params: {methodType: 'PUT', wsNameAndMethod: wsNameAndMethod}, headers: {tokenforreq: tokenForReq}}); //tokenForReq
    if (getParamsForReq.data.result === 'error'){
        return (getParamsForReq.data)
    }
    //console.log(getParamsForReq.data.data);
    //const axiosRes = await axios.get(`${globalApiGwPath.pathForRequests}/${methodName}`, {params:axiParams, headers: {systemtoken:'sometmptoken', fromsystemname:'global_healthws'}});
    const fullPath = getParamsForReq.data.data.pathForReq;
    const tokenForReq2 = getParamsForReq.data.data.onceTokenForReq;
    msLog(`Инициирован вызов межсервисного PUT запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    // let fullPath = `${apigwPath}/${wsNameAndMethod}`;

    const axiosRes = await axios.put(`${fullPath}/${parsedReq[2]}`, axiParams, {headers: {tokenforreq:tokenForReq2}});
    msLog(`Получен ответ от межсервисного PUT запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    return axiosRes.data
}

async function callDel (wsNameAndMethod, axiParams ) {
    const parsedReq = wsNameAndMethod.split('/');
    if (parsedReq.length !== 3){
        msLog(`Некорректное имя DELETE запроса ${wsNameAndMethod} (система/серис/метод)`, 'wrn');
        return {result: 'error', reason: `Некорректное имя DELETE запроса ${wsNameAndMethod} (система/серис/метод)`}
    }

    const s_reqId = 's_'+ nanoid.nanoid(6);
    if (!axiParams) {
        axiParams = {
            s_reqId:s_reqId
        }
    } else {
        axiParams.s_reqId = s_reqId;
    }

    // Обращаемся к global_apigw_bs за актуальным адресом инстанса запрашиваемого сервиса и токен для запроса
    const getParamsForReq = await axios.get(`${globalApiGwPath}/getParamsForReq`, {params: {methodType: 'DELETE', wsNameAndMethod: wsNameAndMethod}, headers: {tokenforreq: tokenForReq}}); //tokenForReq
    if (getParamsForReq.data.result === 'error'){
        return (getParamsForReq.data)
    }
    //console.log(getParamsForReq.data.data);
    //const axiosRes = await axios.get(`${globalApiGwPath.pathForRequests}/${methodName}`, {params:axiParams, headers: {systemtoken:'sometmptoken', fromsystemname:'global_healthws'}});
    const fullPath = getParamsForReq.data.data.pathForReq;
    const tokenForReq2 = getParamsForReq.data.data.onceTokenForReq;
    msLog(`Инициирован вызов межсервисного DELETE запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    // let fullPath = `${apigwPath}/${wsNameAndMethod}`;

    const axiosRes = await axios.delete(`${fullPath}/${parsedReq[2]}`, {params:axiParams, headers: {tokenforreq:tokenForReq2}});
    msLog(`Получен ответ от межсервисного DELETE запроса ${wsNameAndMethod} с идентификатором ${s_reqId}`, 'info');
    return axiosRes.data
}

// Пока подлежит исключению
// async function callAxiGet (axiPath, axiParams) {
//     const s_reqId = 's_'+ nanoid.nanoid(6);
//     let allParams = {fromWsName:wsName, fromInstanceID:instanceID};
//     if (axiParams !== undefined) {
//         Object.assign(axiParams, allParams);
//     }
//     msLog(`Инициирован вызов межсистемного GET запроса к ${axiPath} с идентификатором ${s_reqId}`, 'info');
//     const axiosRes = await axios.get(axiPath, {params:allParams});
//     msLog(`Получен ответ от межсистемного GET запроса от ${axiPath} с идентификатором ${s_reqId}`, 'info');
//     return axiosRes.data
// }
//
// async function callAxiPost (axiosPath, axiParams) {
//     const s_reqId = 's_'+ nanoid.nanoid(6);
//     msLog(`Инициирован вызов межсистемного POST запроса к ${axiPath} с идентификатором ${s_reqId}`, 'info');
//     const axiosRes = await axios.post(axiosPath, axiParams);
//     msLog(`Получен ответ от межсистемного POST запроса от ${axiPath} с идентификатором ${s_reqId}`, 'info');
//     return axiosRes.data
// }
function emit (eventName, data) {
    let eventData = {'eventName':eventName, data};
    //console.log(eventData);
    socketToGlobalApiGwBS.emit('universalEvent', eventData);
}

function start(params){
    const wsPort = params.wsPort;
    const wsCoreKey = params.wsCoreKey;

    const socketServer = jwt.decode(wsCoreKey, {complete: true}).payload.providerAddress;

    const wsId = jwt.decode(wsCoreKey, {complete: true}).payload.wsId;
    const wsType = jwt.decode(wsCoreKey, {complete: true}).payload.wsType;
    systemId = jwt.decode(wsCoreKey, {complete: true}).payload.systemId;
    systemShortName = jwt.decode(wsCoreKey, {complete: true}).payload.systemShortName;

    socketToGlobalProvider = require('socket.io-client')(socketServer,{
        query: {
            token: wsCoreKey, //jwt
            wsName: wsName,
            wsId: wsId,
            instanceID: instanceID,
            wsType: wsType,
            wsVersion: wsVersion,
        }
    });


    socketToGlobalProvider.on('error', (error) => {
        msLog(`Получено событие об ошибке сокет-соединения`, 'err');
    });

// При успешном коннекте
    socketToGlobalProvider.on('connect', function() {
        //sendStartData();
        //console.log('Подключились к socketServerToGlobalProvider');
        msLog(`Подключились к socketServerToGlobalProvider`, 'ok');
        //socket.emit('wsStart', 'wsStartData');
        // console.log('Подключились к socketServerToGlobalProvider');
        // console.log(socketToGlobalProvider.io.opts.query);
    });

    socketToGlobalProvider.on('setGateWayPath', function(data) {
        //wsPortForRequests
        //wsPortForEvents
        msLog(`Получено событие для установки нового gateWayPath`, 'ok');
        setGlobalApiGwPath(data);
        setNewConnectionToGlobalApigwBS(data, wsId, wsPort, wsType)
        //console.log(data)
    });

    socketToGlobalProvider.on('delGateWayPath', function() {
        msLog(`Получено событие об удалении gateWayPath`, 'ok');
        clearGlobalApiGwPath();
    });

    socketToGlobalProvider.on('preparedNewGateWayPath', function() {
        msLog(`Получено сообщение о необходимости смены gateWayPath`, 'ok');
        socketToGlobalProvider.emit('getGateWayPath');
    });


    app.listen(wsPort, function(){
        msLog(`Сервис ${wsName} запущен на ${wsPort} порту`);
    });

}

function setNewConnectionToGlobalApigwBS(data, wsId, wsPort, wsType){
    // console.log('Данные для к коннекта к новому global_apigw_bs')
    // console.log(data)
    socketToGlobalApiGwBS = require('socket.io-client')(data.globalApiGwPath.pathForEvents,{
        query: {
            token: data.globalApiGwPath.tokenForReq, //jwt
            systemShortName: systemShortName,
            systemId: systemId,
            wsName: wsName,
            wsId: wsId,
            instanceID: instanceID,
            wsType: wsType,
            wsVersion: wsVersion,
            wsPort: wsPort,
            instanceIP: ip.address()
        }
    });

    // При успешном коннекте
    socketToGlobalApiGwBS.on('connect', function() {
        msLog(`Подключились к socketToGlobalApiGwBS`, 'ok');
        //console.log(socketToGlobalApiGwBS.id);
    });

    socketToGlobalApiGwBS.on('getAwaitedRequests', function() {
        socketToGlobalApiGwBS.emit('awaitedRequests', awaitedRequests);
        msLog(`Получено событие-запрос списка awaitedRequests`, 'ok');
    });
}

module.exports = {
// Работа с запросами
    // Обработка входящих запросов
    get: get,
    post: post,
    put: put,
    del: del,
    // Для вызова межсервисных апи
    callGet: callGet,
    callPost: callPost,
    callPut: callPut,
    callDel: callDel,
    // Для вызова внешних апи
    // callAxiGet: callAxiGet,
    // callAxiPost: callAxiPost,
// Работа с событиями
//     on: on,
    emit: emit,
    log: msLog,
    start: start,
};