@science-corporation/synapse 0.9.0 → 0.12.0

package/src/config.ts

@@ -1,19 +1,20 @@
 import Node from "./node";
 import { synapse } from "./api/api";
-import ElectricalBroadband from "./nodes/electrical_broadband";
+import BroadbandSource from "./nodes/broadband_source";
 import ElectricalStimulation from "./nodes/electrical_stimulation";
-import OpticalBroadband from "./nodes/optical_broadband";
 import OpticalStimulation from "./nodes/optical_stimulation";
 import SpectralFilter from "./nodes/spectral_filter";
 import SpikeDetect from "./nodes/spike_detect";
+import SpikeSource from "./nodes/spike_source";
 import StreamIn from "./nodes/stream_in";
 import StreamOut from "./nodes/stream_out";
+import { Status, StatusCode } from "./utils/status";
 
 type Connection = [number, number];
 const kNodeTypeObjectMap = {
-  [synapse.NodeType.kElectricalBroadband]: ElectricalBroadband,
+  [synapse.NodeType.kBroadbandSource]: BroadbandSource,
   [synapse.NodeType.kElectricalStimulation]: ElectricalStimulation,
-  [synapse.NodeType.kOpticalBroadband]: OpticalBroadband,
+  [synapse.NodeType.kSpikeSource]: SpikeSource,
   [synapse.NodeType.kOpticalStimulation]: OpticalStimulation,
   [synapse.NodeType.kSpectralFilter]: SpectralFilter,
   [synapse.NodeType.kSpikeDetect]: SpikeDetect,
@@ -29,37 +30,47 @@ class Config {
     return this.nodes.length + 1;
   }
 
-  add(nodes: Node[]) {
+  add(nodes: Node[]): Status {
     for (const node of nodes) {
-      if (!this.addNode(node)) {
-        return false;
+      const status = this.addNode(node);
+      if (!status.ok()) {
+        return status;
       }
     }
-    return true;
+    return new Status();
   }
 
-  connect(fromNode: Node, toNode: Node): boolean {
-    if (fromNode.id === null || toNode.id === null) {
-      return false;
+  connect(fromNode: Node, toNode: Node): Status {
+    if (!fromNode.id || !toNode.id) {
+      return new Status(StatusCode.INVALID_ARGUMENT, "source and destination nodes must have ids");
     }
     this.connections.push([fromNode.id, toNode.id]);
-    return true;
+    return new Status();
   }
 
-  addNode(node: Node): boolean {
-    if (!!node.id) {
-      return false;
+  addNode(node: Node, id?: number): Status {
+    if (node.id) {
+      return new Status(StatusCode.INVALID_ARGUMENT, "node must not have an id");
     }
-    node.id = this._genNodeId();
+
+    if (id === undefined) {
+      id = this._genNodeId();
+    }
+
+    if (this.nodes.find((n) => n.id === id)) {
+      return new Status(StatusCode.INVALID_ARGUMENT, "node id must be unique");
+    }
+
+    node.id = id;
     this.nodes.push(node);
-    return true;
+    return new Status();
   }
 
-  setDevice(device): boolean {
+  setDevice(device): Status {
     for (const node of this.nodes) {
       node.device = device;
     }
-    return true;
+    return new Status();
   }
 
   static fromProto(proto: synapse.IDeviceConfiguration): Config {
@@ -74,7 +85,7 @@ class Config {
       }
 
       const node = NodeType.fromProto(nodeProto);
-      if (!!nodeProto.id) {
+      if (nodeProto.id) {
         node.id = nodeProto.id;
         config.nodes.push(node);
       } else {

package/src/demo.ts

@@ -5,7 +5,7 @@ import { hideBin } from "yargs/helpers";
 import { synapse } from "./api/api";
 import Config from "./config";
 import Device from "./device";
-import ElectricalBroadband from "./nodes/electrical_broadband";
+import ElectricalBroadband from "./nodes/broadband_source";
 import OpticalStimulation from "./nodes/optical_stimulation";
 import StreamIn from "./nodes/stream_in";
 import StreamOut from "./nodes/stream_out";
@@ -48,8 +48,13 @@ const cli = yargs(hideBin(process.argv))
 const info = async (device: Device) => {
   console.log("Info()");
 
-  const info = await device.info();
-  const { serial, name, status, synapseVersion, firmwareVersion, peripherals, configuration } = info;
+  const { status: s, response } = await device.info();
+  if (!s.ok()) {
+    console.error(s.message);
+    return false;
+  }
+
+  const { serial, name, status, synapseVersion, firmwareVersion, peripherals, configuration } = response;
 
   console.log(` - serial:                         ${serial}`);
   console.log(` - name:                           ${name}`);
@@ -89,7 +94,7 @@ const read = async (device: Device, argv: any) => {
   console.log("Reading from device's StreamOut node...");
 
   const { multicastGroup, output } = argv;
-  let ok = true;
+  let status = null;
   let stream = null;
   if (output) {
     console.log(`Writing to file: ${output}`);
@@ -107,9 +112,13 @@ const read = async (device: Device, argv: any) => {
   const config = new Config();
   const nodeEphys = new ElectricalBroadband({
     peripheralId: 3,
-    channels: [{ id: 0, referenceId: 0, electrodeId: 1 }],
+    signal: {
+      electrode: {
+        channels: [{ id: 0, referenceId: 0, electrodeId: 1 }],
+      },
+    },
     bitWidth: 12,
-    sampleRate: 16000,
+    sampleRateHz: 16000,
   });
   const nodeStreamOut = new StreamOut(
     {
@@ -118,26 +127,24 @@ const read = async (device: Device, argv: any) => {
     onMessage
   );
 
-  ok = config.add([nodeEphys, nodeStreamOut]);
-  ok = config.connect(nodeEphys, nodeStreamOut);
-  if (!ok) {
-    console.error("Failed to connect nodes");
+  status = config.add([nodeEphys, nodeStreamOut]);
+  status = config.connect(nodeEphys, nodeStreamOut);
+  if (!status.ok()) {
+    console.error("failed to connect nodes: ", status.message);
     return;
   }
 
   console.log("Configuring device...");
-  try {
-    ok = await device.configure(config);
-  } catch (e) {
-    console.error(e);
+  status = await device.configure(config);
+  if (!status.ok()) {
+    console.error("failed to configure device: ", status.message);
     return;
   }
 
   console.log("Starting device...");
-  try {
-    ok = await device.start();
-  } catch (e) {
-    console.error(e);
+  status = await device.start();
+  if (!status.ok()) {
+    console.error("failed to start device: ", status.message);
     return;
   }
 
@@ -164,7 +171,7 @@ const write = async (device: Device, argv: any) => {
   }
 
   console.log("Writing to device's StreamOut node...");
-  let ok = true;
+  let status = null;
 
   const config = new Config();
   const nodeStreamIn = new StreamIn({
@@ -172,26 +179,29 @@ const write = async (device: Device, argv: any) => {
   });
   const nodeOptical = new OpticalStimulation();
 
-  ok = config.add([nodeStreamIn, nodeOptical]);
-  ok = config.connect(nodeStreamIn, nodeOptical);
-  if (!ok) {
-    console.error("Failed to connect nodes");
+  status = config.add([nodeStreamIn, nodeOptical]);
+  if (!status.ok()) {
+    console.error("Failed to add nodes: ", status.message);
+    return;
+  }
+
+  status = config.connect(nodeStreamIn, nodeOptical);
+  if (!status.ok()) {
+    console.error("Failed to connect nodes: ", status.message);
     return;
   }
 
   console.log("Configuring device...");
-  try {
-    ok = await device.configure(config);
-  } catch (e) {
-    console.error(e);
+  status = await device.configure(config);
+  if (!status.ok()) {
+    console.error("Failed to configure device: ", status.message);
     return;
   }
 
   console.log("Starting device...");
-  try {
-    ok = await device.start();
-  } catch (e) {
-    console.error(e);
+  status = await device.start();
+  if (!status.ok()) {
+    console.error("Failed to start device: ", status.message);
     return;
   }
 
@@ -286,8 +296,8 @@ const main = async () => {
 
   try {
     await info(device);
-  } catch (e) {
-    console.error(e);
+  } catch (err) {
+    console.error(`Failed to get device info (${err.code}): ${err.message}`);
     return;
   }
 

package/src/device.ts

@@ -1,9 +1,12 @@
-import { Channel, credentials } from "@grpc/grpc-js";
+import { Channel, credentials, ServiceError } from "@grpc/grpc-js";
 
+import protos from "./api/proto.json";
 import { synapse } from "./api/api";
 import Config from "./config";
-import { create } from "./utils/client";
-import { getName } from "./utils/enum";
+import { CallOptions, create } from "./utils/client";
+import { fromDeviceStatus, Status } from "./utils/status";
+
+const kSynapseService = "synapse.SynapseDevice";
 
 class Device {
   rpc: any | null = null;
@@ -11,82 +14,133 @@ class Device {
   sockets: synapse.INodeSocket[] = [];
 
   constructor(public uri: string) {
-    this.rpc = create(uri, credentials.createInsecure());
-    if (!this.rpc) {
-      throw new Error(`Failed to create client for ${uri}`);
+    const { status, client } = create(protos, kSynapseService)(uri, credentials.createInsecure());
+    if (!status.ok() || !client) {
+      throw new Error(`Failed to create client for ${uri}: ${status.message}`);
     }
+    this.rpc = client;
   }
 
-  async configure(config: Config): Promise<boolean> {
+  async configure(config: Config, options: CallOptions = {}): Promise<Status> {
     return new Promise((resolve, reject) => {
       config.setDevice(this);
-
       const proto = config.toProto();
-      this.rpc.configure(proto, (err, res) => {
+      this.rpc.configure(proto, options, (err: ServiceError, res) => {
         if (err) {
           reject(err);
         } else {
-          if (this._handleStatusResponse(res!)) {
-            resolve(true);
+          const status = this._handleStatusResponse(res!);
+          if (status.ok()) {
+            resolve(status);
           } else {
-            reject(`Error configuring device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+            reject(new Status(status.code, `failed to configure device: ${status.message}`));
           }
         }
       });
     });
   }
 
-  async info(): Promise<synapse.DeviceInfo> {
+  async info(options: CallOptions = {}): Promise<{ status: Status; response?: synapse.DeviceInfo }> {
     return new Promise((resolve, reject) => {
-      this.rpc.info({}, (err, res) => {
+      this.rpc.info({}, options, (err: ServiceError, res: synapse.DeviceInfo) => {
         if (err) {
           reject(err);
+        } else if (!res) {
+          reject(new Status(err.code, "failed to get device info: " + err.message));
         } else {
-          resolve(res!);
+          const { sockets } = res.status;
+          this.sockets = sockets || [];
+          resolve({ status: new Status(), response: res });
         }
       });
     });
   }
 
-  async start(): Promise<boolean> {
+  async start(options: CallOptions = {}): Promise<Status> {
     return new Promise((resolve, reject) => {
-      this.rpc.start({}, (err, res) => {
+      this.rpc.start({}, options, (err: ServiceError, res: synapse.IStatus) => {
         if (err) {
           reject(err);
         } else {
-          if (this._handleStatusResponse(res!)) {
-            resolve(true);
+          const status = this._handleStatusResponse(res!);
+          if (status.ok()) {
+            resolve(status);
           } else {
-            reject(`Error starting device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+            reject(new Status(status.code, `failed to start device: ${status.message}`));
           }
         }
       });
     });
   }
 
-  async stop(): Promise<boolean> {
+  async stop(options: CallOptions = {}): Promise<Status> {
     return new Promise((resolve, reject) => {
-      this.rpc.stop({}, (err, res) => {
+      this.rpc.stop({}, options, (err: ServiceError, res: synapse.IStatus) => {
         if (err) {
           reject(err);
         } else {
-          if (this._handleStatusResponse(res!)) {
-            resolve(true);
+          const status = this._handleStatusResponse(res!);
+          if (status.ok()) {
+            resolve(status);
           } else {
-            reject(`Error stopping device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+            reject(new Status(status.code, `failed to stop device: ${status.message}`));
           }
         }
       });
     });
   }
 
-  _handleStatusResponse(status: synapse.Status): boolean {
-    const { code, sockets } = status;
-    if (code && (code as any) !== synapse.StatusCode.kOk) {
-      return false;
+  // Logs
+
+  async getLogs(
+    query: synapse.ILogQueryRequest,
+    options: CallOptions = {}
+  ): Promise<{ status: Status; response?: synapse.LogQueryResponse }> {
+    return new Promise((resolve, reject) => {
+      this.rpc.getLogs(query, options, (err: ServiceError, res: synapse.LogQueryResponse) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ status: new Status(), response: res });
+        }
+      });
+    });
+  }
+
+  async tailLogs(
+    query: synapse.ITailLogsRequest,
+    options: CallOptions = {},
+    callbacks: {
+      onData: (data: synapse.LogEntry) => void;
+      onEnd?: () => void;
+      onError?: (err: Error) => void;
+      onStatus?: (status: Status) => void;
+    }
+  ) {
+    const { onData, onEnd, onError, onStatus } = callbacks;
+    const call = this.rpc.tailLogs(query, options);
+    call.on("data", onData);
+    if (onEnd) {
+      call.on("end", onEnd);
+    }
+    if (onError) {
+      call.on("error", onError);
+    }
+    if (onStatus) {
+      call.on("status", (grpcStatus) => {
+        onStatus?.(new Status(grpcStatus.code, grpcStatus.details));
+      });
+    }
+    return call;
+  }
+
+  _handleStatusResponse(status: synapse.IStatus): Status {
+    const { code, message, sockets } = status;
+    if (code !== synapse.StatusCode.kOk) {
+      return fromDeviceStatus({ code, message });
     } else {
       this.sockets = sockets || [];
-      return true;
+      return new Status();
     }
   }
 }

package/src/index.ts

@@ -1,4 +1,7 @@
 export { default as Config } from "./config";
 export { default as Device } from "./device";
 export * from "./nodes";
-export { synapse } from "./api/api";
+export { IStatus, Status, StatusCode } from "./utils/status";
+
+export type { CallOptions } from "./utils/client";
+export * from "./api/api";

package/src/nodes/broadband_source.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class BroadbandSource extends Node {
+  type = synapse.NodeType.kBroadbandSource;
+  config: synapse.IBroadbandSourceConfig;
+
+  constructor(config: synapse.IBroadbandSourceConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      broadbandSource: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.NodeConfig): BroadbandSource {
+    const { broadbandSource } = proto;
+    if (!broadbandSource) {
+      throw new Error("Invalid config, missing broadbandSource");
+    }
+
+    return new BroadbandSource(proto.broadbandSource);
+  }
+}
+
+export default BroadbandSource;

package/src/nodes/index.ts

@@ -1,8 +1,10 @@
-export { default as ElectricalBroadband } from "./electrical_broadband";
+export { default as BroadbandSource } from "./broadband_source";
 export { default as ElectricalStimulation } from "./electrical_stimulation";
-export { default as OpticalBroadband } from "./optical_broadband";
 export { default as OpticalStimulation } from "./optical_stimulation";
 export { default as SpectralFilter } from "./spectral_filter";
 export { default as SpikeDetect } from "./spike_detect";
+export { default as SpikeSource } from "./spike_source";
 export { default as StreamIn } from "./stream_in";
 export { default as StreamOut } from "./stream_out";
+
+export type * from "../api/api";

package/src/nodes/spike_source.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class SpikeSource extends Node {
+  type = synapse.NodeType.kSpikeSource;
+  config: synapse.ISpikeSourceConfig;
+
+  constructor(config: synapse.ISpikeSourceConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      spikeSource: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.NodeConfig): SpikeSource {
+    const { spikeSource } = proto;
+    if (!spikeSource) {
+      throw new Error("Invalid config, missing spikeSource");
+    }
+
+    return new SpikeSource(proto.spikeSource);
+  }
+}
+
+export default SpikeSource;

package/src/nodes/stream_in.ts

@@ -3,11 +3,6 @@ import dgram from "dgram";
 import { synapse } from "../api/api";
 import Node from "../node";
 
-export interface StreamInArgs {
-  dataType: synapse.DataType;
-  shape?: number[];
-}
-
 class StreamIn extends Node {
   type = synapse.NodeType.kStreamIn;
   config: synapse.IStreamInConfig;
@@ -49,7 +44,7 @@ class StreamIn extends Node {
 
     try {
       this._socket.send(data, port, host);
-    } catch (e) {
+    } catch {
       return false;
     }
 

package/src/nodes/stream_out.ts

@@ -18,7 +18,7 @@ class StreamOut extends Node {
     this._onMessage = onMessage;
   }
 
-  async start(): Promise<any> {
+  async start(): Promise<boolean> {
     if (this.device === null) {
       return false;
     }
@@ -45,9 +45,9 @@ class StreamOut extends Node {
 
     this._socket = dgram.createSocket("udp4");
 
-    this._socket.on("error", (err: any) => {});
+    this._socket.on("error", () => {});
 
-    this._socket.on("message", (msg: Buffer, rinfo: any) => {
+    this._socket.on("message", (msg: Buffer) => {
       this._onMessage?.(msg);
     });
 
@@ -65,7 +65,7 @@ class StreamOut extends Node {
     return true;
   }
 
-  async stop(): Promise<any> {
+  async stop(): Promise<boolean> {
     if (this._socket) {
       this._socket.close();
     }

package/src/utils/client.ts

@@ -1,20 +1,45 @@
 import { ChannelCredentials, ChannelOptions, loadPackageDefinition } from "@grpc/grpc-js";
 import { fromJSON } from "@grpc/proto-loader";
+import { Status, StatusCode } from "./status";
 
-import protoJson from "../api/proto.json";
+export interface CallOptions {
+  deadline?: Date;
+}
 
-const loadClient = () => {
-  const definition = fromJSON(protoJson as any, {
-    keepCase: false,
-    arrays: true,
-    enums: Number,
-    defaults: true,
-    oneofs: true,
-  });
-  const descriptor = loadPackageDefinition(definition as any);
-  return (descriptor.synapse as any).SynapseDevice;
+const pick = (obj: any, path: string) => {
+  return path.split(".").reduce((acc, part) => (acc && acc[part]) || null, obj);
 };
 
-export const create = (address: string, credentials: ChannelCredentials, options?: ChannelOptions) => {
-  return new (loadClient())(address, credentials, options);
+const loadClient = (protoJson: object, serviceName: string): { status: Status; factory?: any } => {
+  try {
+    const definition = fromJSON(protoJson as any, {
+      keepCase: false,
+      arrays: true,
+      enums: Number,
+      defaults: true,
+      oneofs: true,
+    });
+
+    const descriptor = loadPackageDefinition(definition as any);
+
+    const service = pick(descriptor, serviceName);
+    if (!service) {
+      return { status: new Status(StatusCode.INTERNAL, `service ${serviceName} not found in proto definition`) };
+    }
+
+    return { status: new Status(StatusCode.OK), factory: service };
+  } catch (error) {
+    return { status: new Status(StatusCode.INTERNAL, "failed to load proto definition: " + error) };
+  }
 };
+
+export const create =
+  (protoJson: object, serviceName: string) =>
+  (address: string, credentials: ChannelCredentials, options?: ChannelOptions): { status: Status; client?: any } => {
+    const { status, factory } = loadClient(protoJson, serviceName);
+    if (!status.ok()) {
+      return { status };
+    }
+    const client = new factory(address, credentials, options);
+    return { status, client };
+  };