sonic-server 1.5.1

Fast, lightweight and schema-less search backend.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

// Sonic
//
// Fast, lightweight and schema-less search backend
// Copyright: 2019, Nikita Vilunov <nikitaoryol@gmail.com>
// License: Mozilla Public License v2.0 (MPL v2.0)

const SonicChannel = require("sonic-channel");

function connect(channel, name) {
  return new Promise((resolve, reject) => {
    channel.connect({
      connected() {
        console.info(
          `=== Sonic Channel succeeded to connect to host (${name}) ===`
        );

        resolve(channel);
      },

      disconnected() {
        console.error(`=== Sonic Channel is now disconnected (${name}) ===`);
      },

      timeout() {
        console.error(`=== Sonic Channel connection timed out (${name}) ===`);
      },

      retrying() {
        console.error(`=== Trying to reconnect to Sonic Channel (${name}) ===`);
      },

      error(error) {
        console.error(
          `=== Sonic Channel failed to connect to host (${name}) ===`, error
        );

        reject(error);
      }
    });
  });
}

async function main(scenario) {
  let parameters = {
    host : "localhost",
    port : 1491,
    auth : "password:test"
  };

  // Connect to Sonic Channel
  let search = new SonicChannel.Search(parameters);
  let ingest = new SonicChannel.Ingest(parameters);

  await Promise.all([
    connect(search, "search"),
    connect(ingest, "ingest")
  ]);

  // Run scenario
  await scenario(search, ingest);

  // Close Sonic Channel
  await Promise.all([
    search.close(),
    ingest.close()
  ]);
}

function wrapper(name, scenario, timeout) {
  console.log(`=== Running test scenario ${name} ===`)

  timeout = (timeout || 1000);

  let timer = new Promise((_, reject) => {
    setTimeout(() => {
      reject("Timeout reached");
    }, timeout);
  });

  let start = process.hrtime();

  Promise.race([
    main(scenario), timer
  ])
    .then(
      () => {
        let end = process.hrtime(start);

        console.log(
          `=== Test scenario ${name} succedeed, execution time: ` +
            `${end[0] + end[1] / 1e9} s ===`
        );
      },

      (error)  => {
        let end = process.hrtime(start);

        console.error(
          (`=== Test scenario ${name} failed, execution time: ` +
            `${end[0] + end[1] / 1e9} s ===`),
          `\nERROR >> ${error}`
        );

        process.exit(-1);
      }
  );
}

module.exports = wrapper;