" +
179 | "
";
181 |
182 | $(".pterm-main").append(txt);
183 | }
184 | }
185 |
186 | function pterm_print_overwrite(text) {
187 | while(text.includes("\x1b[")) {
188 | text = text.replace("\x1b[0m", "");
189 | text = text.replace("\x1b[91m", "");
190 | text = text.replace("\x1b[92m", "");
191 | text = text.replace("\x1b[93m", "");
192 | }
193 |
194 | let lines = text.split("\n");
195 |
196 | for(let i = 0; i < lines.length; i++) {
197 | if(i == 0) {
198 | $(".pterm-row.pterm-text").last().html(txt);
199 | } else {
200 | let txt = "" +
180 | lines[i] + "
" +
201 | "
";
203 | $(".pterm-main").append(txt);
204 | }
205 | }
206 | }
207 |
208 | function pterm_new_progress_bar() {
209 | let txt = "" +
202 | lines[i] + "
" +
210 | "
";
214 |
215 | $(".pterm-main").append(txt);
216 | let m = $(".pterm-main");
217 | m.scrollTop(m.prop("scrollHeight"));
218 | }
219 |
220 | function pterm_new_button(value) {
221 | let id = "id-" + Math.floor(Math.random() * 10000000);
222 | let txt = "" +
211 | "
" +
223 | "
";
226 |
227 | $(".pterm-main").append(txt);
228 | return id;
229 | }
230 |
231 | function pterm_set_progress_bar(val, max) {
232 | let p = (val/max) * 100;
233 | $(".pterm-progress-bar-track").last().width(p + "%");
234 | }
235 |
236 | //
237 | // ------------------------------------------------------------------------------------------------
238 | //
239 |
240 | function pterm_insert_history(line) {
241 | pterm_history_list.push(line);
242 | pterm_history_pos = pterm_history_list.length;
243 | }
244 |
245 | function processLine(line) {
246 | if(line == "") {
247 | return;
248 | }
249 |
250 | let args = getArgsFromLine(line);
251 |
252 | if(args[0] == "echo") {
253 | if(args[1] != null) {
254 | pterm_print(args[1]);
255 | }
256 | pterm_handled = true;
257 | } else if(args[0] == "printenv") {
258 | let envKeys = Object.keys(pterm_env);
259 | for(let i = 0; i < envKeys.length; i++) {
260 | pterm_print(envKeys[i] + "=" + pterm_env[envKeys[i]]);
261 | }
262 | pterm_handled = true;
263 | } else if(args[0] == "export" || args[0] == "set") {
264 | let matchString = new RegExp('^' + pterm_env_var_regex.source + '=' + '(.+)' + '$');
265 |
266 | for(let i = 1; i < args.length; i++) {
267 | let result = args[i].match(matchString);
268 |
269 | if(result != null) {
270 | // found a match to export
271 | let valueMatchString = new RegExp('^' + pterm_quote_regex.source + '$');
272 | let valueResult = result[2].match(valueMatchString);
273 |
274 | let value = result[2];
275 |
276 | if(valueResult != null) {
277 | value = valueResult[2];
278 | }
279 |
280 | pterm_set(result[1], value);
281 | }
282 | }
283 |
284 | for(let i = 0; i < pterm_env_event.length; i++) {
285 | pterm_env_event[i]();
286 | }
287 |
288 | pterm_handled = true;
289 | } else if(args[0] == "unset") {
290 | if(args[1] in pterm_env) {
291 | delete pterm_env[args[1]];
292 | for(let i = 0; i < pterm_env_event.length; i++) {
293 | pterm_env_event[i]();
294 | }
295 | }
296 | pterm_handled = true;
297 | } else {
298 | $(".pterm-cursor").css("visibility", "hidden");
299 | pterm_editing = false;
300 | execute(pterm_cmd_event, args);
301 | }
302 |
303 | pterm_insert_history(line);
304 | }
305 |
306 | $(document).ready(function() {
307 | $(document).keydown(function(event) {
308 | if($("*").is(":focus")) {
309 | return;
310 | }
311 |
312 | pterm_process_key(event);
313 | });
314 | });
315 |
316 | function pterm_process_key(event) {
317 | // don't scroll on arrow or space
318 | if([32, 37, 38, 39, 40].indexOf(event.keyCode) > -1) {
319 | event.preventDefault();
320 | }
321 |
322 | if(event.metaKey) {
323 | if(event.key == "k") {
324 | $(".pterm-line:not(:last)").remove();
325 | }
326 | }
327 | else if(event.altKey) {
328 | if(event.key == "ArrowLeft") {
329 | if(pterm_current_pos == 0) {
330 | return;
331 | }
332 |
333 | pterm_current_pos--;
334 |
335 | let c = pterm_current_line.charAt(pterm_current_pos);
336 |
337 | // 1. if c is space, then continue until non-space,
338 | // and then just right of next space
339 | // 2. if c is non-space, then continue until just right of next space
340 |
341 | if(c == ' ') {
342 | while((c=pterm_current_line.charAt(pterm_current_pos)) == ' ' && pterm_current_pos > 0) {
343 | pterm_current_pos--;
344 | }
345 | }
346 |
347 | while((c=pterm_current_line.charAt(pterm_current_pos)) != ' ' && pterm_current_pos > 0) {
348 | pterm_current_pos--;
349 | }
350 |
351 | if(pterm_current_pos != 0 || pterm_current_line.charAt(0) == ' ') {
352 | pterm_current_pos++;
353 | }
354 | }
355 | else if(event.key == "ArrowRight") {
356 | if(pterm_current_pos == pterm_current_line.length) {
357 | return;
358 | }
359 |
360 | let c = pterm_current_line.charAt(pterm_current_pos);
361 |
362 | // 1. if c is space, then continue until non-space,
363 | // 2. if c is non-space, then continue until just right of next space
364 |
365 | if(c != ' ') {
366 | while((c=pterm_current_line.charAt(pterm_current_pos)) != ' ' && pterm_current_pos < pterm_current_line.length) {
367 | pterm_current_pos++;
368 | }
369 | }
370 |
371 | while((c=pterm_current_line.charAt(pterm_current_pos)) == ' ' && pterm_current_pos < pterm_current_line.length) {
372 | pterm_current_pos++;
373 | }
374 | }
375 | }
376 | else if(event.ctrlKey) {
377 | if(event.key == "a") {
378 | pterm_current_pos = 0;
379 | }
380 | else if(event.key == "e") {
381 | pterm_current_pos = pterm_current_line.length;
382 | }
383 | else if(event.key == "c") {
384 | newLine();
385 | }
386 | else if(event.key == "r") {
387 | // reverse search
388 | }
389 | }
390 | else if(event.key == "ArrowLeft") {
391 | if(pterm_current_pos > 0) {
392 | pterm_current_pos--;
393 | }
394 | }
395 | else if(event.key == "ArrowRight") {
396 | if(pterm_current_pos < pterm_current_line.length) {
397 | pterm_current_pos++;
398 | }
399 | }
400 | else if(event.key == "ArrowUp") {
401 | if(pterm_history_pos == 0) {
402 | return;
403 | }
404 |
405 | let line = pterm_history_list[--pterm_history_pos];
406 | pterm_current_line = line;
407 | pterm_current_pos = line.length;
408 | }
409 | else if(event.key == "ArrowDown") {
410 | if(pterm_history_pos >= pterm_history_list.length - 1) {
411 | return;
412 | }
413 |
414 | let line = pterm_history_list[++pterm_history_pos];
415 | pterm_current_line = line;
416 | pterm_current_pos = line.length;
417 | }
418 | else if(event.key == "Delete") {
419 | // delete
420 | if(pterm_current_pos < pterm_current_line.length) {
421 | pterm_current_line = pterm_current_line.substring(0, pterm_current_pos) +
422 | pterm_current_line.substring(pterm_current_pos + 1);
423 | }
424 | }
425 | else if(event.key == "Enter") {
426 | // handle Enter
427 | pterm_handled = false;
428 | processLine(pterm_current_line);
429 | if(pterm_handled) {
430 | newLine();
431 | }
432 | }
433 | else if(event.keyCode == 8) {
434 | if(pterm_current_pos > 0) {
435 | pterm_current_line = pterm_current_line.substring(0, pterm_current_pos - 1) +
436 | pterm_current_line.substring(pterm_current_pos);
437 | pterm_current_pos--;
438 | }
439 | }
440 | else if((32 <= event.keyCode && event.keyCode <= 126) || (event.key.length == 1)) {
441 | let key = event.key;
442 |
443 | pterm_current_line = pterm_current_line.substring(0, pterm_current_pos) +
444 | key +
445 | pterm_current_line.substring(pterm_current_pos);
446 | pterm_current_pos++;
447 | }
448 | else {
449 | // console.log(event);
450 | }
451 |
452 | let w = $(".pterm-cursor").width();
453 | $(".pterm-current > .pterm-text").html(pterm_current_line);
454 | $(".pterm-current").width(w * (pterm_current_line.length + 1));
455 | $(".pterm-cursor").css("left", w * pterm_current_pos);
456 | }
457 |
458 | $(document).on("paste", function(event){
459 | // get clipboard data
460 | let data = event.originalEvent.clipboardData.getData('text');
461 | pterm_current_line = pterm_current_line.substring(0, pterm_current_pos) +
462 | data +
463 | pterm_current_line.substring(pterm_current_pos);
464 | pterm_current_pos += data.length;
465 |
466 | let w = $(".pterm-cursor").width();
467 | $(".pterm-current > .pterm-text").html(pterm_current_line);
468 | $(".pterm-current").width(w * (pterm_current_line.length + 1));
469 | $(".pterm-cursor").css("left", w * pterm_current_pos);
470 | });
--------------------------------------------------------------------------------
/src-node-client/blesh.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | let net = require('net');
4 |
5 | class Blesh {
6 | constructor() {
7 | this.onReceiveDataEvent = null;
8 | this.server = null;
9 | this.socket = null;
10 | this.writeQueue = new Uint8Array(0);
11 | }
12 |
13 | static isSupported() {
14 | return true;
15 | }
16 |
17 | onReceiveData(fnc) {
18 | this.onReceiveDataEvent = fnc;
19 | }
20 |
21 | send(data) {
22 | if(this.socket != null) {
23 | if(this.writeQueue.length > 0) {
24 | this.socket.write(this.writeQueue);
25 | this.writeQueue = new Uint8Array(0);
26 | }
27 |
28 | this.socket.write(data);
29 | } else {
30 | // append to the writeQueue
31 | let tmp = new Uint8Array(this.writeQueue.length + data.length);
32 | tmp.set(this.writeQueue);
33 | tmp.set(data, this.writeQueue.length);
34 | this.writeQueue = tmp;
35 | }
36 | }
37 |
38 | stop() {
39 | if(this.socket != null) {
40 | this.socket.end();
41 | this.socket = null;
42 | }
43 |
44 | if(this.server != null) {
45 | this.server.close();
46 | this.server = null;
47 | }
48 | }
49 |
50 | start(port) {
51 | let self = this;
52 |
53 | let p = new Promise(function(resolve, reject) {
54 | self.server = net.createServer((c) => {
55 | // 'connection' listener
56 | console.log('* SSH client connected');
57 | self.socket = c;
58 |
59 | c.on('end', () => {
60 | console.log('* SSH client disconnected.');
61 | });
62 |
63 | c.on('data', function(r) {
64 | self.onReceiveDataEvent(r);
65 | });
66 | });
67 |
68 | self.server.on('error', (err) => {
69 | throw err;
70 | });
71 |
72 | self.server.listen(port, () => {
73 | console.log("* SSH tunnel server started.");
74 | });
75 |
76 | resolve(true);
77 | });
78 |
79 | return p;
80 | }
81 | }
82 |
83 | module.exports = { Blesh };
84 |
--------------------------------------------------------------------------------
/templates/main.ejs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | " +
224 | ""
225 | "
29 |
30 |
552 |
553 |
554 |
555 |
556 |
557 |
558 |
559 |
--------------------------------------------------------------------------------
/test/vector-setup/addOta.e2e.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | const { expect } = require("chai");
6 | const should = require("chai").should();
7 |
8 | const path = require("path");
9 |
10 | const clicmd = require("../../utils/clicmd");
11 | const fs = require("../../utils/fsPromise");
12 | const { VECTOR_WEB_SETUP } = require("../../tools/common.js").filePath;
13 |
14 | const cliProcess = clicmd.create(VECTOR_WEB_SETUP, "."); // this will return a new object { execute }
15 | const testOta = "https://ddltestota.s3.amazonaws.com/test.ota";
16 |
17 | const getTestPath = (stage) =>
18 | path.join(VECTOR_WEB_SETUP, `../site/firmware/${stage}/test.ota`);
19 |
20 | const inventoryPath = path.join(
21 | VECTOR_WEB_SETUP,
22 | `../site/data/inventory.json`
23 | );
24 |
25 | module.exports = () => {
26 | describe("when using ota-add", () => {
27 | let originalJson = {};
28 |
29 | before(async () => {
30 | originalJson = await fs.readFile(inventoryPath);
31 | });
32 |
33 | after(async () => {
34 | await fs.writeFile(inventoryPath, originalJson);
35 | });
36 |
37 | beforeEach(async () => {
38 | await fs.writeFile(inventoryPath, originalJson);
39 | });
40 |
41 | it("should throw error when url in not given", async () => {
42 | try {
43 | await cliProcess.execute(["ota-add"]);
44 | } catch (err) {
45 | should.exist(err);
46 | }
47 | });
48 |
49 | it("should add ota to prod when no other option is used", async () => {
50 | try {
51 | await cliProcess.execute(["ota-add", testOta]);
52 |
53 | let testPath = getTestPath("prod");
54 | expect(await fs.exists(testPath)).to.be.true;
55 |
56 | //Cleanup
57 | fs.unlink(testPath);
58 | } catch (err) {
59 | should.not.exist(err);
60 | }
61 | });
62 |
63 | it("should add ota to a specific stack", async () => {
64 | try {
65 | await cliProcess.execute(["ota-add", testOta, "-e", "test"]);
66 |
67 | let testPath = getTestPath("test");
68 | expect(await fs.exists(testPath)).to.be.true;
69 |
70 | //Cleanup
71 | fs.unlink(testPath);
72 | } catch (err) {
73 | should.not.exist(err);
74 | }
75 | });
76 |
77 | it("should add ota with a specific name", async () => {
78 | try {
79 | await cliProcess.execute(["ota-add", testOta, "-n", "abc"]);
80 |
81 | let testPath = path.join(
82 | VECTOR_WEB_SETUP,
83 | `../site/firmware/prod/abc.ota`
84 | );
85 | expect(await fs.exists(testPath)).to.be.true;
86 |
87 | //Cleanup
88 | fs.unlink(testPath);
89 | } catch (err) {
90 | should.not.exist(err);
91 | }
92 | });
93 | });
94 | };
95 |
--------------------------------------------------------------------------------
/test/vector-setup/approveOta.e2e.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | const chai = require("chai");
6 | const chaiAsPromised = require("chai-as-promised");
7 | const expect = chai.expect;
8 | const should = chai.should();
9 | chai.use(chaiAsPromised);
10 |
11 | const path = require("path");
12 |
13 | const clicmd = require("../../utils/clicmd");
14 | const fs = require("../../utils/fsPromise");
15 | const rmdir = require("../../utils/rmdir");
16 |
17 | const { prompt, filePath } = require("../../tools/common");
18 | const { VECTOR_WEB_SETUP } = filePath;
19 |
20 | const cliProcess = clicmd.create(VECTOR_WEB_SETUP, "."); // this will return a new object { execute }
21 | const testOta = "https://ddltestota.s3.amazonaws.com/test.ota";
22 |
23 | const testStore = path.join(VECTOR_WEB_SETUP, `../site/firmware/test`);
24 |
25 | const inventoryPath = path.join(
26 | VECTOR_WEB_SETUP,
27 | `../site/data/inventory.json`
28 | );
29 |
30 | module.exports = () => {
31 | describe("when using ota-approve", () => {
32 | let originalJson = {};
33 |
34 | before(async () => {
35 | originalJson = await fs.readFile(inventoryPath);
36 | rmdir(testStore);
37 | });
38 |
39 | after(async () => {
40 | await fs.writeFile(inventoryPath, originalJson);
41 | });
42 |
43 | beforeEach(async () => {
44 | await fs.writeFile(inventoryPath, originalJson);
45 | });
46 |
47 | afterEach(() => {
48 | rmdir(testStore);
49 | });
50 |
51 | it("should add checksum if the checksum doesn't exist", async () => {
52 | await expect(
53 | cliProcess.execute(["ota-add", testOta, "-e", "test"])
54 | ).to.be.eventually.contain("Downloading ota. It can take some minutes.");
55 |
56 | let process = cliProcess.execute(["ota-approve", "test/test.ota"]);
57 |
58 | await expect(process).to.be.eventually.contain(
59 | prompt.OTA_APPROVE_SUCCESS
60 | );
61 | });
62 |
63 | it("should throw error if the store doesn't exists", async () => {
64 | let process = cliProcess.execute([
65 | "ota-approve",
66 | "non_existent/test.ota",
67 | ]);
68 |
69 | await expect(process).to.be.eventually.contain(prompt.STORE_NOT_EXISTS);
70 | });
71 |
72 | it("should not approve again if the checksum exist", async () => {
73 | await expect(
74 | cliProcess.execute(["ota-add", testOta, "-e", "test"])
75 | ).to.be.eventually.contain("Downloading ota. It can take some minutes.");
76 |
77 | await expect(
78 | cliProcess.execute(["ota-approve", "test/test.ota"])
79 | ).to.be.eventually.contain(prompt.OTA_APPROVE_SUCCESS);
80 |
81 | await expect(
82 | cliProcess.execute(["ota-approve", "test/test.ota"])
83 | ).to.be.eventually.contain(prompt.CHECKSUM_EXITS);
84 | });
85 | });
86 | };
87 |
--------------------------------------------------------------------------------
/test/vector-setup/index.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | describe("The vector-web-setup end to end", () => {
6 | require("./addOta.e2e")();
7 | require("./approveOta.e2e")();
8 | });
9 |
--------------------------------------------------------------------------------
/tools/common.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | var path = require("path");
6 |
7 | const pathJoin = (str) => path.join(__dirname, str);
8 |
9 | module.exports = {
10 | filePath: {
11 | DEF_SETTINGS_FILE: pathJoin("../default-data/settings.json"),
12 | DEF_INVENTORY_FILE: pathJoin("../default-data/inventory.json"),
13 | PTERM_LESS_FILE: pathJoin("../less/pterm.less"),
14 | RTS_MAIN_JS: pathJoin("../rts-js/main.js"),
15 |
16 | DATA_FOLDER: pathJoin("../site/data"),
17 | SETTINGS_FILE: pathJoin("../site/data/settings.json"),
18 | INVENTORY_FILE: pathJoin("../site/data/inventory.json"),
19 |
20 | PTERM_CSS_FILE: pathJoin("../site/css/pterm.css"),
21 | RTS_JS_FILE: pathJoin("../site/js/rts.js"),
22 |
23 | FIRMWARE_FOLDER: pathJoin("../site/firmware"),
24 |
25 | VECTOR_WEB_SETUP: pathJoin("../vector-web-setup.js"),
26 | },
27 |
28 | prompt: {
29 | STORE_NOT_EXISTS: "Inventory store doesn't exists",
30 |
31 | OTA_APPROVE_SUCCESS: "Ota approved",
32 | OTA_NOT_EXISTS: "Ota doesn't exists",
33 | CHECKSUM_EXITS: "Checksum already present",
34 | },
35 |
36 | DEFUALT_ENV: "prod",
37 | };
38 |
--------------------------------------------------------------------------------
/tools/configure.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | var commander = require("commander");
6 | var fs = require("fs");
7 | var less = require("less");
8 | var browserify = require("browserify");
9 |
10 | const {
11 | DATA_FOLDER,
12 | SETTINGS_FILE,
13 | INVENTORY_FILE,
14 |
15 | DEF_SETTINGS_FILE,
16 | DEF_INVENTORY_FILE,
17 |
18 | PTERM_LESS_FILE,
19 | PTERM_CSS_FILE,
20 | RTS_JS_FILE,
21 | RTS_MAIN_JS,
22 | } = require("./common.js").filePath;
23 |
24 | const ensureDataFolderExists = () => {
25 | if (!fs.existsSync(DATA_FOLDER)) {
26 | fs.mkdirSync(DATA_FOLDER);
27 | }
28 | };
29 | const processSettings = (force) => {
30 | try {
31 | ensureDataFolderExists();
32 | console.log("Checking Settings file at " + SETTINGS_FILE);
33 |
34 | if (force) {
35 | console.log(
36 | "Overriding Settings file using file from " + DEF_SETTINGS_FILE
37 | );
38 | fs.copyFileSync(DEF_SETTINGS_FILE, SETTINGS_FILE);
39 | } else if (fs.existsSync(SETTINGS_FILE)) {
40 | console.log("Settings file exist. No action taken");
41 | } else {
42 | console.log("Adding Settings file using file from " + DEF_SETTINGS_FILE);
43 | fs.copyFileSync(DEF_SETTINGS_FILE, SETTINGS_FILE);
44 | }
45 | } catch (err) {
46 | console.log(err);
47 | }
48 | };
49 |
50 | const processInventory = (force) => {
51 | try {
52 | ensureDataFolderExists();
53 | console.log("Checking Inventory file at " + INVENTORY_FILE);
54 |
55 | if (force) {
56 | console.log(
57 | "Overriding Inventory file using file from " + DEF_INVENTORY_FILE
58 | );
59 | fs.copyFileSync(DEF_INVENTORY_FILE, INVENTORY_FILE);
60 | } else if (fs.existsSync(INVENTORY_FILE)) {
61 | console.log("Inventory file exists. No action taken");
62 | } else {
63 | console.log(
64 | "Adding Inventory file using file from " + DEF_INVENTORY_FILE
65 | );
66 | fs.copyFileSync(DEF_INVENTORY_FILE, INVENTORY_FILE);
67 | }
68 | } catch (err) {
69 | console.log(err);
70 | }
71 | };
72 |
73 | const processLess = async () => {
74 | console.log("Adding css files at " + PTERM_LESS_FILE);
75 | const content = fs.readFileSync(PTERM_LESS_FILE, "utf-8");
76 | const result = await less.render(content);
77 | fs.writeFileSync(PTERM_CSS_FILE, result.css, "utf-8");
78 | };
79 |
80 | const processRts = () => {
81 | console.log("Adding rts.js file at " + RTS_JS_FILE);
82 |
83 | return new Promise((resolve, reject) => {
84 | browserify()
85 | .add(RTS_MAIN_JS)
86 | .bundle()
87 | .pipe(fs.createWriteStream(RTS_JS_FILE))
88 | .on("finish", resolve)
89 | .on("error", reject);
90 | });
91 | };
92 |
93 | const configure = new commander.Command("configure");
94 |
95 | configure
96 | .description("configure the settings and assets for websetup")
97 | .option("-rs, --reset-setting", "Use to force override settings.json")
98 | .option("-ri, --reset-inventory", "Use to force override inventory.json")
99 | .action(async (cmd) => {
100 | console.log("Running configures...");
101 |
102 | processSettings(cmd.resetSetting);
103 | processInventory(cmd.resetInventory);
104 | processLess();
105 | await processRts();
106 |
107 | console.log("Done.");
108 | });
109 |
110 | module.exports = configure;
111 |
--------------------------------------------------------------------------------
/tools/inventory/firmwareStore.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | const axios = require("axios");
6 | const fs = require("../../utils/fsPromise");
7 |
8 | const { filePath, prompt } = require("../common.js");
9 | const { Ota } = require("./ota");
10 | const { generateChecksum } = require("../../utils/hash");
11 |
12 | const healthStatus = {
13 | checksum: {
14 | OK: "ok",
15 | MISMATCH: "mismatch",
16 | NOT_DEFINED: "checksum not defined",
17 | },
18 |
19 | filing: {
20 | OK: "ok",
21 | ABSENT: "absent",
22 | },
23 | };
24 |
25 | class FirmwareStore {
26 | constructor(env, otas) {
27 | this.location = filePath.FIRMWARE_FOLDER + "/" + env;
28 | this.otas = otas;
29 | this.name = env;
30 | }
31 |
32 | async setup() {
33 | try {
34 | const storeExists = await fs.exists(this.location);
35 | if (!storeExists) {
36 | await fs.mkdir(this.location);
37 | }
38 | } catch (err) {
39 | if (err.code == "ENOENT") {
40 | let frimwareFolderExists = await fs.exists(filePath.FIRMWARE_FOLDER);
41 | if (!frimwareFolderExists) {
42 | await fs.mkdir(filePath.FIRMWARE_FOLDER);
43 | await this.setup();
44 | }
45 | } else {
46 | this.log(ota, err);
47 | }
48 | }
49 | }
50 |
51 | async downloadAndSaveConfig(ota, options) {
52 | let force = options.force == undefined ? false : options.force;
53 |
54 | if (!(await this.exists(ota)) || force) {
55 | await this.download(ota);
56 | } else {
57 | this.log(ota, "Ota already exists. No action was taken");
58 | }
59 | }
60 |
61 | async download(ota) {
62 | if (ota === undefined) {
63 | this.log(ota, prompt.OTA_NOT_EXISTS);
64 | return;
65 | }
66 |
67 | this.log(ota, "Downloading ota. It can take some minutes.");
68 |
69 | const writer = fs.createWriteStream(this.getPath(ota));
70 | const respose = await axios.get(ota.url, { responseType: "stream" });
71 | respose.data.pipe(writer);
72 |
73 | return new Promise((resolve, reject) => {
74 | writer.on("finish", () => {
75 | if (this.otas.filter((o) => ota.compare(o)).length > 0) {
76 | this.log(ota, "The ota is already present in inventory manifest");
77 | } else {
78 | this.otas.push(ota);
79 | }
80 |
81 | resolve();
82 | });
83 |
84 | writer.on("error", () =>
85 | reject("There was an error while downlaoding the ota. Please the url")
86 | );
87 | });
88 | }
89 |
90 | exists(ota) {
91 | return fs.exists(this.getPath(ota));
92 | }
93 |
94 | getPath(ota) {
95 | return this.location + `/${ota.name}`;
96 | }
97 |
98 | getOta(name) {
99 | const ota = this.otas.filter((o) => o.name === name)[0];
100 |
101 | if (ota === undefined) {
102 | throw new Error(
103 | `[${this.name} - ${name}] Ota doesn't exists in inventory. You need to add the ota using 'vector-setup ota-add'.`
104 | );
105 | }
106 |
107 | return ota;
108 | }
109 |
110 | async sync(name) {
111 | let ota = this.getOta(name);
112 |
113 | await this.syncOta(ota);
114 | }
115 |
116 | async syncAll() {
117 | this.otas.map(async (ota) => {
118 | this.log(ota, "Starting Sync");
119 | await this.syncOta(ota);
120 | });
121 | }
122 |
123 | async syncOta(ota) {
124 | if (!(await this.exists(ota))) {
125 | await this.download(ota);
126 | }
127 |
128 | if (ota.checksum === undefined) {
129 | this.log(
130 | ota,
131 | "WARN: No checksum defined for the ota. The ota could be harmful"
132 | );
133 | } else {
134 | let generatedChecksum = await generateChecksum(this.getPath(ota));
135 | generatedChecksum === ota.checksum
136 | ? this.log(ota, "Checksum matched. Ota is safe to use")
137 | : this.log(ota, "Checksum mismatched. Delete the ota and retry");
138 | }
139 | }
140 |
141 | async addChecksum(name) {
142 | let ota = this.getOta(name);
143 |
144 | if (ota.checksum != undefined) {
145 | this.log(ota, prompt.CHECKSUM_EXITS);
146 | return;
147 | }
148 |
149 | let checksum = await generateChecksum(this.getPath(ota));
150 | ota.checksum = checksum;
151 |
152 | this.log(ota, prompt.OTA_APPROVE_SUCCESS);
153 | }
154 |
155 | log(ota, txt) {
156 | console.log(`[${this.name} - ${ota.name}] ${txt}`);
157 | }
158 | }
159 |
160 | FirmwareStore.freeze = (store) => {
161 | let frozenOtas = store.otas.reduce((acc, ota) => {
162 | acc.push(Ota.freeze(ota));
163 | return acc;
164 | }, []);
165 |
166 | return frozenOtas;
167 | };
168 |
169 | FirmwareStore.revive = (env, json) => {
170 | if (!Array.isArray(json)) {
171 | throw new Error(`${this.env} is not saved as array`);
172 | }
173 |
174 | let otas = [];
175 | json.map((o) => {
176 | otas.push(Ota.thaw(o));
177 | });
178 |
179 | return new FirmwareStore(env, otas);
180 | };
181 |
182 | const getStoreFor = async (env, json) => {
183 | try {
184 | let store = FirmwareStore.revive(env, json);
185 | await store.setup();
186 | return store;
187 | } catch (err) {
188 | console.log(err);
189 | }
190 | };
191 |
192 | module.exports = {
193 | getStoreFor,
194 | freezeStore: (store) => FirmwareStore.freeze(store),
195 | healthStatus,
196 | };
197 |
--------------------------------------------------------------------------------
/tools/inventory/index.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | const fs = require("../../utils/fsPromise");
6 |
7 | const { filePath, prompt } = require("../common.js");
8 | const { Ota } = require("./ota");
9 | const { getStoreFor, freezeStore, healthStatus } = require("./firmwareStore");
10 |
11 | const DEFAULT_INV = JSON.stringify({});
12 |
13 | class Inventory {
14 | constructor() {
15 | this.stores = {};
16 | }
17 |
18 | async setup() {
19 | try {
20 | await fs.readFile(filePath.INVENTORY_FILE);
21 | } catch (err) {
22 | if (err.code == "ENOENT") {
23 | let dataFolderExists = await fs.exists(filePath.DATA_FOLDER);
24 | if (!dataFolderExists) {
25 | await fs.mkdir(filePath.DATA_FOLDER);
26 | }
27 |
28 | await fs.writeFile(filePath.INVENTORY_FILE, DEFAULT_INV);
29 | }
30 | }
31 | }
32 |
33 | async addOta(url, options) {
34 | try {
35 | let env = options.environment;
36 | let name = options.otaName;
37 | let ota = new Ota(url, name);
38 |
39 | let store = this.stores[env];
40 |
41 | // The store for the environment doesn't exist
42 | if (store == undefined) {
43 | store = await getStoreFor(env, []);
44 | this.stores[env] = store;
45 | }
46 |
47 | await store.downloadAndSaveConfig(ota, { force: options.force });
48 | } catch (err) {
49 | console.log(err.message);
50 | }
51 | }
52 |
53 | async syncOta(name, env) {
54 | try {
55 | let store = this.stores[env];
56 | await store.sync(name);
57 | this.stores[env] = store;
58 | } catch (err) {
59 | console.log(err.message);
60 | }
61 | }
62 |
63 | async syncAll() {
64 | try {
65 | for (const key in this.stores) {
66 | const store = this.stores[key];
67 | await store.syncAll();
68 | }
69 | } catch (err) {
70 | console.log(err.message);
71 | }
72 | }
73 |
74 | async approveOta(name, env) {
75 | try {
76 | let store = this.stores[env];
77 | if (store == undefined) {
78 | console.log(prompt.STORE_NOT_EXISTS);
79 | return;
80 | }
81 |
82 | await store.addChecksum(name);
83 |
84 | this.stores[env] = store;
85 | } catch (err) {
86 | console.log(err.message);
87 | }
88 | }
89 |
90 | async getInv() {
91 | let rawData = await fs.readFile(filePath.INVENTORY_FILE);
92 | let json = JSON.parse(rawData);
93 | return json;
94 | }
95 |
96 | async saveInv(json) {
97 | await fs.writeFile(filePath.INVENTORY_FILE, JSON.stringify(json));
98 | }
99 |
100 | async cryo() {
101 | let json = Object.keys(this.stores).reduce((acc, key) => {
102 | acc[key] = freezeStore(this.stores[key]);
103 | return acc;
104 | }, {});
105 |
106 | await this.saveInv(json);
107 | }
108 |
109 | async revive() {
110 | try {
111 | let json = await this.getInv();
112 | for (var env in json) {
113 | this.stores[env] = await getStoreFor(env, json[env]);
114 | }
115 | } catch (err) {
116 | console.log(err.message);
117 | }
118 | }
119 | }
120 |
121 | module.exports = {
122 | getInventory: async () => {
123 | try {
124 | let vectorInventory = new Inventory();
125 | await vectorInventory.setup();
126 | await vectorInventory.revive();
127 |
128 | return vectorInventory;
129 | } catch (err) {
130 | console.log(err.message);
131 | }
132 | },
133 | };
134 |
--------------------------------------------------------------------------------
/tools/inventory/ota.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | function parseURL(url) {
6 | let obj = new URL(url);
7 | obj.filename = url.substring(url.lastIndexOf("/") + 1);
8 | return obj;
9 | }
10 |
11 | function parseName(name) {
12 | return name.substring(name.lastIndexOf(".") + 1) == "ota"
13 | ? name
14 | : name + ".ota";
15 | }
16 |
17 | class Ota {
18 | constructor(url, name, checksum) {
19 | this.url = url;
20 | this.name = name != undefined ? parseName(name) : parseURL(url).filename;
21 | this.checksum = checksum;
22 | }
23 |
24 | toString() {
25 | return JSON.stringify(this);
26 | }
27 |
28 | compare(obj) {
29 | return obj.name === this.name;
30 | }
31 | }
32 |
33 | // Static method to convert to a basic structure with a class identifier
34 | Ota.freeze = (ota) => ({
35 | url: ota.url,
36 | name: ota.name,
37 | checksum: ota.checksum,
38 | });
39 |
40 | // Static method to reconstitute a Ota from the basic structure
41 | Ota.thaw = (json) => new Ota(json.url, json.name, json.checksum);
42 |
43 | module.exports = { Ota };
44 |
--------------------------------------------------------------------------------
/tools/ota.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2019-2020 Digital Dream Labs. See LICENSE file for details. */
2 |
3 | "use strict";
4 |
5 | const commander = require("commander");
6 | const fs = require("fs");
7 |
8 | const { getInventory } = require("./inventory");
9 | const { DEFUALT_ENV } = require("./common");
10 |
11 | const { filePath } = require("./common.js");
12 |
13 | const otaAdd = new commander.Command("ota-add");
14 | otaAdd
15 | .arguments("
31 |
537 |
32 | 
37 | 
43 | 
49 | 
55 | 
61 | 
67 |
68 |
37 |
43 |
49 |
55 |
61 |
67 |
73 |
89 |
74 | 
75 |
76 |
75 |
77 |
88 | 78 | Vector Web Setup uses Web Bluetooth which requires Google Chrome. 79 | See 80 | 83 | Mozilla's compatibility table 84 | 85 | for details. 86 |
87 |
94 |
104 |
95 |
103 |
96 |
98 | 99 |
100 | 101 |
102 | Choose the stack you want to use
97 |98 | 99 |
100 | 101 |
105 |
119 |
106 | 
111 |
112 |
111 |
113 |
118 | 114 | There was an error loading the settings.json file. To view the 115 | file click here 116 |
117 |
120 |
163 |
121 |
141 |
122 | 
126 |
128 |
126 | 1. Place Vector on his charger.
127 |
129 | 
133 |
140 |
133 |
134 |
135 | 2. Double-press Vector's button and then click "PAIR WITH
136 | VECTOR."
137 |
138 |
139 |
142 |
154 |
143 | 
147 |
153 |
147 |
148 | Wait until Vector finishes restarting, then click "PAIR WITH
149 | VECTOR." If Vector doesn't connect automatically, try
150 | double-pressing Vector's button.
151 |
152 |
155 |
161 |
162 |
164 |
170 |
165 |
169 |
166 |
167 |
168 |
171 |
178 | Enable auto-setup flow.
185 | 191 |
192 | 178 | Enable auto-setup flow.
185 | 191 |
193 |
197 | 198 |
199 |
205 |
194 | Error trying to connect Vector to wifi.
195 |
196 | 197 | 198 |
199 |
200 |
201 | Don't see your network? Click to join custom.
202 |
203 |
204 |
206 |
213 |
220 | 226 |
227 | 213 |
220 | 226 |
233 |
331 |
332 |
234 | Authorize vector with the account
used in Vector Mobile app
235 |
245 |
266 |
272 | Reset Password
273 | Create Account 274 |
275 | used in Vector Mobile app
235 |
236 | Error.
237 |
238 | 245 |
246 |
253 |
265 |
259 | 
263 |
264 |
263 | 266 |
272 | Reset Password
273 | Create Account 274 |
276 | Create a new account
277 |
289 |
296 |
317 |
323 |
329 |
330 | 277 |
278 | Error.
279 |
280 |
281 | 289 |
296 |
297 |
304 |
316 |
310 |
314 |
315 |
314 | 317 |
323 |
329 |
333 | Choose a timezone
334 | 379 |
380 | Choose temperature unit
381 | 385 |
386 | Choose distance system
387 | 391 |
392 | Enable Amazon Alexa.
398 | Allow Digital Dream Labs to upload anonymized logs to improve 404 | Vector.
405 | 411 |
412 | 334 | 379 |
380 | Choose temperature unit
381 | 385 |
386 | Choose distance system
387 | 391 |
392 | Enable Amazon Alexa.
398 | Allow Digital Dream Labs to upload anonymized logs to improve 404 | Vector.
405 | 411 |
413 |
454 |
414 |
416 | 417 |
418 | Choose the image to upload
415 | 416 | 417 |
419 |
434 |
420 |
425 |
426 |
425 |
427 |
433 | 428 | No OTA's present in firmware folder. Try "vector-setup ota-sync" 429 | to sync all otas present in inventory.json file. To view the 430 | file click here 431 |
432 |
435 |
439 | 440 | Updating Vector...
441 | 446 | 452 |
453 |
436 | Error while updating Vector.
437 |
438 | 439 | 440 | Updating Vector...
441 | 446 | 452 |
455 | 
460 |
462 | 460 |
Vector setup is complete!
461 |
463 |
468 | 474 |
475 |
476 | 464 | Update completed. After Vector reboots, you will need to discover 465 | him again. 466 |
467 |468 | 474 |
477 |
518 |
519 |
478 |
487 |
479 |
486 |
480 | hello
484 |
485 | hello
484 |
488 |
517 |
489 |
505 |
490 |
495 |
496 |
495 |
497 |
501 |
502 |
503 |
504 |
501 |
506 |
516 | Download Logs
507 |
508 | Downloading logs...
509 |
514 |
515 |
520 |
536 |
521 | 
522 |
523 |
532 |
522 |
533 | 
534 |
535 |
534 | <%= serverIp %>
538 | <%= networkIp %>
539 | <%= port %>
540 |
541 |
551 |
542 |
550 |
543 |
549 | $
544 |
545 |
546 |
547 |
548 |