wsinstance/index.js

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

// Зависимости
let app = require('express')();
let timestamp = require('time-stamp');
let _ = require('lodash');
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;
const wsClientConfig = require('../../wsClientConfig.json');
const wsCoreKey = wsClientConfig.wsCoreKey;
const wsPort = wsClientConfig.wsPort;

let apigwPath = null;
let tokenForReq = null;

const instanceID = nanoid(10);


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

let socketServer = jwt.decode(wsCoreKey, {complete: true}).payload.wsEventBusAddress;
let systemName = jwt.decode(wsCoreKey, {complete: true}).payload.systemName;
const wsType = jwt.decode(wsCoreKey, {complete: true}).payload.wsType;
// Характеристики инстанса в сессии сокет-соединения
let socket = require('socket.io-client')(socketServer,{
    query: {
        token: wsCoreKey, //jwt
        wsName: wsName,
        instanceID: instanceID,
        wsType: wsType,
    }
});

let awaitedEvents = [];
let awaitedRequests = [];

let wsStartData = {
    wsName: wsName,
    wsVersion: wsVersion,
    awaitedEvents: awaitedEvents,
    awaitedRequests: awaitedRequests,
    instanceParams:{
        instanceID: instanceID,
        instanceIP: ip.address(),
        instancePort: wsPort}
};


// Отправляем данные о запущенном сервисе
function sendStartData(){
    socket.emit('wsStart', wsStartData);
}

// При успешном коннекте
socket.on('connect', function() {
    setTimeout( sendStartData, 2000);
    //console.log(wsStartData);
});

// Сервисы ядра перезапущены
socket.on('afterCoreRestart', function(data) {
    //console.log(data);
    setTimeout( sendStartData, 2000);
    //console.log(wsStartData);
});

socket.on('coreIsDisabled', function(data) {
    console.log(data);
});

// Сервисы инфраструктуры хапущены\перезапущены
socket.on('infrastructureStart', function(data) {
    //console.log(data);
    if (systemName !=='infrastructure.core'){
        setTimeout( sendStartData, 2000);
    }

    //console.log(wsStartData);
});

// Сервисы инфраструктуры хапущены\перезапущены
socket.on('infrastructureStop', function(data) {
    console.log(data);
});

socket.on('regiseredInSystem', function(data) {
    console.log('Инстанс сервиса зарегистрирован в системе');
    //console.log(data);
    tokenForReq = data.tokenForReq;
});

socket.on('error', (error) => {
    console.log(error)
});

socket.on('apigwPath', function(data) {
    apigwPath = data.apigwPath
});

// let on = function (eventName, ...temps) {
async function on (eventName, ...temps) {
    let right = {};
    let onEventAction = null; // функция передаваемая в обработчик выова
    if (temps.length === 2) {
        console.log('Есть параметры, проверяем кому доступен/или кому не доступен');
        if (!temps[0].forFS){right.forFS = 0} else {right.forFS = temps[0].forFS}
        if (!temps[0].forBS){right.forBS = 0} else {right.forBS = temps[0].forBS}
        onEventAction = temps[1];
    } else {
        console.log('Недоступен никому');
        right = {forFS: 0, forBS: 0};
        onEventAction = temps[0];
    }
    //console.log(personalEventName);
    function step1 (data){
        //console.log(`Получено сообщение с идентификатором: ${data.eventId}`);
        let dataToChangeEventState = {'eventId':data.eventId,'eventState':'received'};
        socket.emit('changeEventState', dataToChangeEventState);
    }
    async function step2 (data){
        try {
            await onEventAction(data);
            step3(data);
        } catch (err) {
            //console.log(`Ошибка обработки по сообщению с идентификатором: ${data.eventId}`);
            let dataToChangeEventState = {'eventId':data.eventId,'eventState':'error'};
            socket.emit('changeEventState', dataToChangeEventState);
        }
    }
    function step3 (data){
        //console.log(`Выполнена обработка по сообщению с идентификатором: ${data.eventId}`);
        let dataToChangeEventState = {'eventId':data.eventId,'eventState':'succsess'};
        socket.emit('changeEventState', dataToChangeEventState);
    }
    function run (data){
        step1(data);
        step2(data);
    }
    // Непосредственно сама подписка на событие 'instanceId\eventName' между шиной и сервисом
    socket.on(eventName, function(data){
        run(data)
    });
    // Регистрация подписки в MQ всех обработчиков, принадлежащих сервису
    awaitedEvents.push({eventName:eventName, right: right}) // не забыть что был ещё personalEventName: personalEventName ()
}

function emit (eventName, ...temps) {
    // !!! todo Здесь заменяем на добавление в emittedEvents
    //console.log('Вызывается только в момент обращения к методу req');
    //todo добавить rights
    let right = {};
    let data = null;
    if (temps.length === 2) {
        //console.log('Есть параметры, проверяем кому доступен/или кому не доступен');
        if (!temps[0].forFS){right.forFS = 0} else {right.forFS = temps[0].forFS}
        if (!temps[0].forBS){right.forBS = 0} else {right.forBS = temps[0].forBS}
        data = temps[1];
    } else {
        right = {forFS: 0, forBS: 0};
        data = temps[0];
    }
    let eventData = {'eventName':eventName, right, data};
    //console.log(eventData);
    socket.emit('universalEvent', eventData);
}

// Проверка что запрос пришел именно через apigw
app.use(function(req, res, next){
    if (req.method ==='OPTIONS'){
        next();
    }
    else {
        //console.log(`Промежуточная функция до вызова метода`);
        // if ((req.method ==='GET' ||  req.method ==='POST' || req.method ==='PUT') &&  ( req.headers.toinstanceid === instanceID)){
        if ((['GET', 'POST', 'PUT', 'DELETE'].includes(req.method)) &&  ( req.headers.toinstanceid === instanceID)){
            next();
        } else {
            return res.send({result: 'error', reason: `Запрос к сервису ${wsName} минуя apigw`})
        }

    }
});

async function get (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'GET'});
    app.get(name, next)
}
async function post (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'POST'});
    app.post(name, next)
}
async function put (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'PUT'});
    app.put(name, next)
}
async function del (name, next) {
    awaitedRequests.push({methodName:name, methodType: 'DELETE'});
    app.delete(name, next)
}

async function callGet (wsNameAndMethod, axiParams ) {
    let fullPath = `${apigwPath}/${wsNameAndMethod}`;
    const axiosRes = await axios.get(fullPath, {params:axiParams, headers: {tokenForReq:tokenForReq}});
    return axiosRes.data
}

async function callPost (wsNameAndMethod, axiParams ) {
    let fullPath = `${apigwPath}/${wsNameAndMethod}`;
    const axiosRes = await axios.post(fullPath, axiParams, {headers: {tokenForReq:tokenForReq}});
    return axiosRes.data
}

async function callPut (wsNameAndMethod, axiParams ) {
    let fullPath = `${apigwPath}/${wsNameAndMethod}`;
    const axiosRes = await axios.put(fullPath, axiParams, {headers: {tokenForReq:tokenForReq}});
    return axiosRes.data
}

async function callDel (wsNameAndMethod, axiParams ) {
    let fullPath = `${apigwPath}/${wsNameAndMethod}`;

    const axiosRes = await axios.delete(fullPath, {params:axiParams, headers: {tokenForReq:tokenForReq}});
    return axiosRes.data
}

async function callAxiGet (axiPath, axiParams ) {
    let allParams = {fromWsName:wsName, fromInstanceID:instanceID};
    if (axiParams !== undefined) {
        Object.assign(axiParams, allParams);
    }
    const axiosRes = await axios.get(axiPath, {params:allParams});
    return axiosRes.data
}

async function callAxiPost (axiosPath) {
    const axiosRes = await axios.post(axiosPath);
    return axiosRes.data
}


app.listen(wsPort, function(){
    console.log(`${timestamp('[DD-MM-YYYY HH:mm:ss.ms]')}: Сервис ${wsName} запущен на ${wsPort} порту`)
});

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
};