Hooks API

Hooks API 提供了一种将自定义代码插入运行时作的某些关键点的方法。

注意：编辑器中还有一个 hooks api，但它还不够成熟，所以目前没有记录下来供一般使用。

RED.hooks API

RED.hooks.add( hookName, handlerFunction )

注册一个新的 hook 处理程序。

这是要为其注册处理程序的钩子的名称. hookName

可以选择为它添加钩子的标签 - 的后缀。然后，可以使用该标签来删除处理程序。onSend.my-hooks RED.hooks.remove

调用时，将使用单个有效负载对象调用 hook 处理程序 - 详细信息其中将特定于 Hook。

处理程序可以采用可选的第二个参数 - 要调用的回调函数当处理程序完成其工作时。

当处理程序完成其工作时，它必须：

  • 正常返回
  • 调用不带参数的回调函数
  • 返回一个 resolve

它对 payload 对象所做的任何修改都将被传递。

如果处理程序想要停止对事件的进一步处理（例如，它不希望将消息传递到流中的下一个节点），则必须：

  • return （严格 - 不是类似 false 的值）false
  • 使用 false 调用回调函数
  • 返回一个 Promise，该 Promise 以值 . false

如果处理程序遇到应记录的错误，则必须：

  • throw 一个 Error
  • 调用回调函数，并显示 Error
  • 返回一个 Promise 拒绝，并返回 Error

如果函数被定义为双参数版本（接受回调函数），它必须使用该回调 - 它返回的任何值都将被忽略。

1
2
3
RED.hooks.add("preDeliver.my-hooks", (sendEvent) => {
    console.log(`About to deliver to ${sendEvent.destination.id}`);
});

RED.hooks.remove（ hookName ）

删除 hook 处理程序。

只能删除使用标记名称 （for example） 注册的处理程序。onSend.my-hooks

要删除所有具有给定标签的钩子，可以使用 *.my-hooks

1
RED.hooks.remove("*.my-hooks");

Messaging Hooks

消息钩子允许将自定义代码添加到节点之间的消息路径中。

下图显示了消息收发路径中可用的钩子集。

Hooks

onSend

节点已使用一条或多条消息进行调用。node.send()

钩子传递一个对象数组。这些对象中的消息正是节点传递给的消息 - 这意味着可能存在对同一消息对象的重复引用 SendEvent``node.send

这个钩子应该同步完成，以避免意外行为。

如果它需要异步工作，则必须在接收到的事件中克隆并替换 message 对象。它还_必须_将 property 设置为以确保不会对消息进行后续克隆 cloneMessage false

如果 hook 返回，则消息将不会继续进行 false

1
2
3
4
// Example synchronous onSend hook
RED.hooks.add("onSend", (sendEvents) => {
    console.log(`Sending ${sendEvents.length} messages`);
});

preRoute

消息即将路由到其目标。

钩子传递一个 . SendEvent

这个钩子应该同步完成，以避免意外行为。

如果它需要异步工作，则必须在接收到的事件中克隆并替换 message 对象。它还_必须_将 property 设置为以确保不会对消息进行后续克隆 cloneMessage false

如果钩子返回，则消息将不再继续 false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Example async preRoute hook
RED.hooks.add("preRoute", (sendEvent, done) => {
    // As this hook needs to do async work, clone the message if needed
    if (sendEvent.cloneMessage) {
        sendEvent.msg = RED.util.cloneMessage(sendEvent.msg);
        sendEvent.cloneMessage = false;
    }
    someAsyncAPI(sendEvent).then(() => {
        done()
    }).catch(err => {
        // An error means stop processing this message
        done(err);
    })
});

preDeliver

即将投递的消息

钩子传递一个 .此时，本地路由器已经确定要发送到的节点并设置属性的 . SendEvent``destination.node``SendEvent

如果需要，将克隆该消息。

如果 hook 返回，则消息将不会继续进行。false

1
2
3
4
// Example preDeliver hook
RED.hooks.add("preDeliver", (sendEvent) => {
    console.log(`About to deliver to ${sendEvent.destination.id}`);
});

postDeliver

已将消息调度到其目标。

钩子传递一个。消息以异步方式传递到 hooks 执行。SendEvent

1
2
3
4
// Example preDeliver hook
RED.hooks.add("preDeliver", (sendEvent) => {
    console.log(`Message dispatched to ${sendEvent.destination.id}`);
});

onReceive

节点即将接收一条消息。

钩子被传递一个 . ReceiveEvent

如果 hook 返回，则消息将不会继续进行 false

1
2
3
4
// Example onReceive hook
RED.hooks.add("onReceive", (receiveEvent) => {
    console.log(`Message about to be passed to node: ${receiveEvent.destination.id}`);
});

postReceive

节点已收到一条消息。

当消息被提供给 node 的处理程序。ReceiveEvent input

1
2
3
4
// Example postReceive hook
RED.hooks.add("postReceive", (receiveEvent) => {
    console.log(`Message received: ${receiveEvent.msg.payload}`);
});

onComplete

节点已完成并显示一条消息或为其记录了错误。

钩子被传递一个 CompleteEvent

1
2
3
4
5
6
// Example onComplete hook
RED.hooks.add("onComplete", (completeEvent) => {
    if (completeEvent.error) {
        console.log(`Message completed with error: ${completeEvent.error}`);
    }
});

事件对象

SendEvent 对象

1
2
3
4
5
6
7
8
9
10
11
12
13
{
    "msg": "<message object>",
    "source": {
        "id": "<node-id>",
        "node": "<node-object>",
        "port": "<index of port being sent on>",
    },
    "destination": {
        "id": "<node-id>",
        "node": undefined,
    },
    "cloneMessage": "true|false"
}

ReceiveEvent 对象

1
2
3
4
5
6
7
{
    "msg": "<message object>",
    "destination": {
        "id": "<node-id>",
        "node": "<node-object>",
    }
}

CompleteEvent 对象

1
2
3
4
5
6
7
8
{
    "msg": "<message object>",
    "node": {
        "id": "<node-id>",
        "node": "<node-object>"
    },
    "error": "<error passed to done, otherwise, undefined>"
}

Node Install Hooks

Node Install Hooks 允许在安装新的 npm 模块时添加自定义代码 - 适用于 Nodes 和 External 模块。

Hooks

preInstall

在运行之前调用以安装 npm 模块 npm install

钩子将传递一个对象，该对象包含有关要安装的模块的信息 InstallEvent

1
2
3
4
5
6
7
8
9
{
    "module": "<npm module name>",
    "version": "<version to be installed>",
    "url": "<optional url to install from>",
    "dir": "<directory to run the install in>",
    "isExisting": "<boolean> this is a module we already know about",
    "isUpgrade": "<boolean> this is an upgrade rather than new install",
    "args": [ "an array", "of the args", "that will be passed to npm"]
}

钩子可以修改 InstallEvent 以更改 npm 的运行方式。例如，可以修改数组以更改传递给的参数 args npm

如果 hook 返回，则将跳过，并且处理将继续，就像它已运行一样。这将允许使用一些替代机制 - 只要它导致模块安装在预期的目录下。false npm install node_modules

如果 hook 抛出错误，则安装将完全失败。

1
2
3
RED.hooks.add("preInstall", (installEvent) => {
    console.log(`About to install ${installEvent.module}@${installEvent.version}`);
});

postInstall

在完成安装 npm 模块后调用 npm install

请注意，如果钩子返回，则不会运行，但此钩子仍将被调用 preInstall false npm install

此挂钩可用于运行所需的任何安装后活动。

例如，在 Electron 环境中运行时，需要重新构建该模块：

1
2
3
4
5
6
7
8
RED.hooks.add("postInstall",  (installEvent, done) => {
    child_process.exec("npm run rebuild " +  installEvent.module,
        {cwd: installEvent.dir},
        (err, stdout, stderr) => {
            done();
        }
    );
});

如果 hook 抛出错误，则安装将完全失败。

如果前面返回错误，则不会调用此 hook npm install

preUninstall

在运行之前调用以卸载 npm 模块 npm remove

钩子将传递一个对象，该对象包含有关要删除的模块的信息。UninstallEvent

1
2
3
4
5
{
    "module": "<npm module name>",
    "dir": "<directory to run the remove in>",
    "args": [ "an array", "of the args" , "we will pass to npm"]
}

钩子可以修改 UninstallEvent 以更改 npm 的运行方式。例如可以修改数组以更改传递给的参数 args npm

如果钩子返回，则将跳过，并且处理将继续，就像它已经运行一样。这将允许一些替代机制以供使用。false npm remove

如果 hook 抛出错误，则卸载将完全失败。

1
2
3
RED.hooks.add("preUninstall", (uninstallEvent) => {
    console.log(`About to remove ${uninstallEvent.module}`);
});

postUninstall

在完成删除 npm 模块后调用 npm remove

请注意，如果钩子返回，则不会运行，但此钩子仍将被调用。`preUninstall false npm remove

此挂钩可用于运行所需的任何卸载后活动。

如果钩子抛出错误，它将被记录下来，但卸载将干净地完成，因为我们无法在它完成后回滚。npm remove

1
2
3
RED.hooks.add("postUninstall",  (uninstallEvent) => {
    console.log(`Removed ${uninstallEvent.module}`);
});

事件对象

InstallEvent对象

1
2
3
4
5
6
7
8
9
{
    "module": "<npm module name>",
    "version": "<version to be installed>",
    "url": "<optional url to install from>",
    "dir": "<directory to run the install in>",
    "isExisting": "<boolean> this is a module we already know about",
    "isUpgrade": "<boolean> this is an upgrade rather than new install",
    "args": [ "an array", "of the args", "we will pass to npm"]
}

UninstallEvent 对象

1
2
3
4
5
{
    "module": "<npm module name>",
    "dir": "<directory to run the remove in>",
    "args": [ "an array", "of the args", "we will pass to npm"]
}