busrt 0.5.5

Local and network IPC bus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

"use strict";

// payloads will be packed/unpacked as msgpack
import * as msgpack from "msgpackr";
import sleep from "sleep-promise";

import {
  Bus,
  Rpc,
  Frame,
  QoS,
  BusError,
  BusErrorCode
} from "busrt";

// RPC notification handler
const onNotification = async (ev) => {
  console.log(ev.getPayload());
};

// RPC call handler
const onCall = async (ev) => {
  const payload = ev.getPayload();
  if (payload.length > 0) {
    console.log(msgpack.unpack(payload));
  }
  const method = ev.method.toString();
  if (method == "test") {
    return msgpack.pack({ ok: true });
  } else if (method == "err") {
    throw new BusError(-777, "test error");
  } else {
    throw new BusError(
      BusErrorCode.RpcMethodNotFound,
      Buffer.from(`no such method: ${method}`)
    );
  }
};

// frame handler (broadcasts and topics)
const onFrame = async (ev) => {
  const payload = ev.frame.getPayload();
  console.log(
    ev.frame.primary_sender,
    ev.frame.topic,
    payload.length > 0 ? msgpack.unpack(payload) : null
  );
};

const main = async () => {
  // create and connect a new client
  const bus = new Bus("js");
  await bus.connect("/opt/eva4/var/bus.ipc");
  const op = await bus.send("test", msgpack.pack("123"));
  try {
    await op.waitCompleted();
  } catch (err) {
    console.log(err.code, err.message?.toString());
  }
  // init RPC layer
  const rpc = new Rpc(bus);
  // init RPC handlers if incoming event handling is required
  rpc.onNotification = onNotification;
  rpc.onCall = onCall;
  rpc.onFrame = onFrame;
  await bus.subscribe("#");
  await bus.publish("test", msgpack.pack("hello"));
  // send test call
  let payload = { i: "#" };
  // call rpc test method, no payload, no response required
  await rpc.call0("target", "test");
  // call rpc test method and wait for the response
  try {
    const request = await rpc.call("eva.core", "test");
    const result = await request.waitCompleted();
    console.log(msgpack.unpack(result.getPayload()));
  } catch (err) {
    console.log(err.code, err.message.toString());
  }
  //return;
  // handle local RPC methods while connected
  while (rpc.isConnected()) {
    await sleep(1000);
  }
  await bus.disconnect();
};

main();