CoteJS 创建多个服务不起作用

Question

我使用cote.js 创建了多个服务，我在自己的文件中有 40 个服务。所以问题是，如果我启动其中两个，它们可以正常工作，但如果我启动第三个或全部，它们不起作用，包括之前工作的两个，控制台输出的屏幕截图：

这是应该的（当启动两个服务时）

但这就是得到的结果（当启动两个以上时）：

request journey begins 是应用的第一个中间件中的第一行代码

sending... 是在调用 requester.send 函数之前的输出

recieved: null是requester.send函数回调中第一行代码执行的输出，null是回调的error参数。

我的代码是网站文档页面中的普通/普通请求者/响应者，只是其中一项服务来自具有 express listen 功能的应用程序（ExpressJS 应用程序）。

任何帮助将不胜感激，在此先感谢。

我的请求者：

const requester = new Requester({
    name: 'app-main',
    key: process.env.APP_NAME
}, {
    redis: {
        host: process.env.REDIS_HOST,
        port: process.env.REDIS_PORT
    }
} as any);

app.set('requester', requester);

我基本上在我的应用程序的整个路由中都使用这个请求者

我的回复者：

import {config} from 'dotenv';
import {basename, resolve} from 'path';
import {Responder} from 'cote';

import * as moment from 'moment';

import {ServiceCallback, ServiceRequest, LoggingParam} from '../helpers/types';
import logger from '../logger';

config({
    path: resolve(__dirname, '..', '.env')
});

const responder = new Responder({
    name: basename(__filename).substring(0, basename(__filename).indexOf('.service')),
    key: process.env.APP_NAME
}, {
    redis: {
        host: process.env.REDIS_HOST,
        port: Number(process.env.REDIS_PORT)
    }
} as any);

responder.on(basename(__filename).substring(basename(__filename).indexOf('.') + 1, basename(__filename).indexOf('.service')), (request: ServiceRequest, callback: ServiceCallback) => {
    const logParam: LoggingParam = {
        level: 'info',
        load: {
            route: {
                userAgent: request.userAgent,
                ip: request.ip,
                body: request.requestBody,
                name: 'test'
            },
            content: {
                message: 'Test function accessed'
            }
        }
    };

    logger(logParam);

    callback(null, {
        status: 200,
        body: `
            <h1>API is up</h1>
            <p>Server time is ${moment().utcOffset(3).toDate()}</p>
        `
    });
});

我的路线声明示例：

router.post('/settings', (request: Request, response: Response) => requestHandler(request, response, 'settings'));

请求处理函数：

export function requestHandler(request: express.Request, response: express.Response, handle: string): void {
    const requester: Requester = request.app.get('requester');

    const requestObject: ServiceRequest = {
        type: handle,
        channel: request.body.channel,
        requestBody: request.body.data,
        user: request.body.user,
        userAgent: request.get('User-Agent'),
        ip: request.ip
    };

    requester.send(requestObject, (error: any, result: ServiceResponse) => {
        if (process.env.NODE_ENV === 'development' || !request.body.keyCombo) {
            response.status(result.status).send(result.body);

            return;
        }

        let dataToEncrypt = result.body;

        if (result.body.constructor === {}.constructor) {
            dataToEncrypt = JSON.stringify(result.body);
        }

        const credentials = request.body.keyCombo.split(';');

        const key = enc.Utf8.parse(credentials[0]);
        const iv = enc.Utf8.parse(credentials[1]);

        const toEncrypt = enc.Utf8.parse(dataToEncrypt);

        const encrypted = AES.encrypt(toEncrypt, key, { iv: iv }).toString();

        response.status(result.status).send(encrypted);
    });
}

如果您需要我发布更多代码，请尽管询问。

Answer 1

如果你没有解决这个问题，我只是遇到了同样的问题，你必须使用密钥

Keys cote 有另一种机制来创建称为键的分区。 由于每个组件都发现并尝试与每个组件进行通信 地平线上的其他组件（这称为“网状网络”），如果 不同的服务请求和响应不同类型的消息， 您将遇到丢失的消息。换句话说，如果服务 A 响应消息 X 和 Y，服务 B 响应消息 Z 和 T，你会丢失一半的消息，因为消息 Z 和 T 会 也以服务 A 结束，但它不知道如何处理它们。这 服务 B 也是如此：消息 X 和 Y 将最终到达它，但是 服务 B 不知道如何响应它们。