@altronix/cli 0.2.0 → 0.3.0

package/src/index.ts

@@ -1,19 +1,32 @@
 import { getLogger } from "@altronix/device";
 import { program } from "commander";
-import setCloud from "./setCloud";
-import setIp from "./setIp";
-import setDhcp from "./setDhcp";
+import * as poe from "./poe";
+import * as cloud from "./cloud";
+import * as ip from "./ip";
+import * as dhcp from "./dhcp";
+import * as about from "./about";
+import { runUpdate } from "./update";
 
 (async function main() {
   getLogger().debug("starting app");
 
   program.name("atx").description("access linq device via cli").version("TODO");
 
+  program
+    .command("get-about")
+    .description("get about data on the device")
+    .action(about.getter);
+
   program
     .command("set-cloud")
     .description("update network interface on the device")
     .argument("<endpoint>", "cloud service location")
-    .action(setCloud);
+    .action(cloud.setter);
+
+  program
+    .command("get-cloud")
+    .description("get cloud endpoint on the device")
+    .action(cloud.getter);
 
   program
     .command("set-ip")
@@ -21,12 +34,44 @@ import setDhcp from "./setDhcp";
     .argument("<ip>", "set IP address")
     .argument("<sn>", "set SN address")
     .argument("<gw>", "set GW address")
-    .action(setIp);
+    .action(ip.setter);
+
+  program
+    .command("get-ip")
+    .description("get ip interface on the device")
+    .action(ip.getter);
 
   program
     .command("set-dhcp")
     .description("update ip interface [DHCP]")
-    .action(setDhcp);
+    .action(dhcp.setter);
+
+  program
+    .command("set-poe-port-on")
+    .description("turn on a poe port")
+    .argument("<port>", "index of port to turn on")
+    .action(poe.setPortOn);
+
+  program
+    .command("set-poe-port-off")
+    .description("turn off a poe port")
+    .argument("<port>", "index of port to turn on")
+    .action(poe.setPortOff);
+
+  program
+    .command("get-poe-ports")
+    .description("read the poe port data")
+    .action(poe.getPorts);
+
+  program
+    .command("update")
+    .description("run firmware update from file")
+    .argument("<file>", "file to update device with")
+    .action(runUpdate);
 
-  await program.parseAsync();
+  try {
+    await program.parseAsync();
+  } catch (e) {
+    console.error(e.json ? e.json() : e);
+  }
 })();

package/src/ip.ts

@@ -0,0 +1,10 @@
+import { NetIp } from "@altronix/cbor";
+import { cliRunGet, cliRunPut } from "./common";
+
+export function setter(ip: string, sn: string, gw: string): Promise<void> {
+  return cliRunPut("/api/v1/net/ip", new NetIp({ ip, sn, gw }));
+}
+
+export function getter(): Promise<void> {
+  return cliRunGet("/api/v1/net/ip", NetIp);
+}

package/src/poe.ts

@@ -0,0 +1,16 @@
+import { PoePort } from "@altronix/cbor";
+import { cliRunGetArray, cliRunPut } from "./common";
+
+export function getPorts(): Promise<void> {
+  return cliRunGetArray("/api/v1/netway/ports", PoePort);
+}
+
+export function setPortOn(port: number): Promise<void> {
+  let data = new PoePort({ enabled: true });
+  return cliRunPut(`/api/v1/netway/ports?port=${port}`, data);
+}
+
+export function setPortOff(port: number): Promise<void> {
+  let data = new PoePort({ enabled: false });
+  return cliRunPut(`/api/v1/netway/ports?port=${port}`, data);
+}

package/src/update.ts

@@ -0,0 +1,98 @@
+/*
+ *  This example will listen for the first connected device and make a get
+ *  request for the about data and log the about data to the console.
+ */
+import {
+  ConnectedEvent,
+  installDebugLogger,
+  getLogger,
+  CONNECTED,
+} from "@altronix/device";
+import { About, Update } from "@altronix/cbor";
+import { from, concat, defer } from "rxjs";
+import { take, filter, switchMap, concatMap, map, tap } from "rxjs/operators";
+import linq from "./linq";
+import fs from "fs";
+
+function chunks(data: Uint8Array, size: number): Uint8Array[] {
+  let arr = [];
+  let remainder = data.length % size;
+  function slicer(n: number) {
+    for (let i = 0; i < n; i++) {
+      let idx = i * size;
+      arr.push(data.slice(idx, idx + size));
+    }
+  }
+  if (remainder == 0) {
+    slicer(data.length / size);
+  } else {
+    let n = Math.ceil(data.length / size);
+    let end = size * (n - 1);
+    slicer(n - 1);
+    let last = new Uint8Array(size);
+    last.set(data.slice(end));
+    arr.push(last);
+  }
+  return arr;
+}
+
+installDebugLogger();
+const logger = getLogger();
+
+// Reduce a blob of binary data and convert into an Update[]
+function updateReducer(arr: Update[], data: Uint8Array, idx: number) {
+  let update = new Update({ data, offset: idx * 512 });
+  // NOTE: Have to initialize the Uint8Array across binding this way
+  // https://gitlab.altronix.com/software-engineering/sdk/atx-zdk/-/issues/1
+  update.data = data;
+  return arr.concat(update);
+}
+
+export function runUpdate(file: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const sub = linq
+      .listen()
+      .pipe(
+        filter((ev): ev is ConnectedEvent => ev.type == CONNECTED),
+        take(1),
+        switchMap(({ device }) => linq.get(device.about.sid, "/api/v1/about")),
+        map(About.fromCbor),
+        switchMap(({ sid: serial, verPrj }) => {
+          logger.info("found device", { serial, version: verPrj });
+          logger.info("sending update      :", { file });
+          return from(fs.promises.readFile(file)).pipe(
+            switchMap((update) => {
+              // Chunk up the update file into packets and send update to device
+              const packets = chunks(update, 512).reduce(updateReducer, []);
+              const length = packets.length;
+              const urlStart = "/api/v1/update/start";
+              const urlTransfer = "/api/v1/update/transfer";
+              const urlFinish = "/api/v1/update/finish";
+              let sent = 0;
+              const start$ = defer(() => linq.get(serial, urlStart));
+              const transfer$ = from(packets).pipe(
+                concatMap((u) => linq.put(serial, urlTransfer, u.cbor())),
+                map((meta) => ({ code: meta.json().code, sent, length })),
+                tap(() => sent++)
+              );
+              const finished$ = defer(() => linq.get(serial, urlFinish));
+              return concat(start$, transfer$, finished$);
+            })
+          );
+        })
+      )
+      .subscribe({
+        next: async (mesg) => {
+          logger.info("<-", { ...mesg });
+          resolve();
+        },
+        error: async (error) => (await linq.shutdown(), reject(error)),
+        complete: async () => (await linq.shutdown(), resolve()),
+      });
+
+    process.on("SIGINT", async () => {
+      await linq.shutdown();
+      sub.unsubscribe();
+    });
+  });
+}