@science-corporation/synapse 2.0.0 → 2.2.2

package/src/demo.ts

@@ -1,325 +0,0 @@
-import fs from "fs";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-
-import { synapse } from "./api/api";
-import Config from "./config";
-import Device from "./device";
-import ElectricalBroadband from "./nodes/broadband_source";
-import OpticalStimulation from "./nodes/optical_stimulation";
-import StreamIn from "./nodes/stream_in";
-import StreamOut from "./nodes/stream_out";
-import { discover } from "./utils/discover";
-import { getName } from "./utils/enum";
-import { getClientIp } from "./utils/ip";
-
-const cli = yargs(hideBin(process.argv))
-  .help()
-  .command("discover", "Discover synapse devices")
-  .command("read", "Read from StreamOut node", {
-    "udp-port": {
-      alias: "p",
-      type: "string",
-      description: "UDP port",
-      default: "50038",
-    },
-    output: {
-      alias: "o",
-      type: "string",
-      description: "Output file",
-    },
-    uri: {
-      alias: "u",
-      type: "string",
-      demandOption: true,
-    },
-  })
-  .command("write", "Write to StreamIn node", {
-    input: {
-      alias: "i",
-      type: "string",
-      description: "Input file",
-    },
-    uri: {
-      alias: "u",
-      type: "string",
-      demandOption: true,
-    },
-  });
-
-const info = async (device: Device) => {
-  console.log("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}`);
-  console.log(` - synapse version:                ${synapseVersion || "<unknown>"}`);
-  console.log(` - firmware version:               ${firmwareVersion || "<unknown>"}`);
-
-  console.log(
-    ` - status:                         ${status.code} (${getName(synapse.StatusCode, status.code)})${
-      status.message ? `: "${status.message}"` : ""
-    }`
-  );
-  console.log(`   - state:                          ${getName(synapse.DeviceState, status.state)}`);
-
-  console.log(`   - sockets:                        ${status.sockets?.length || 0}`);
-  status.sockets?.forEach(({ nodeId, bind }) => {
-    console.log(`     - node [${nodeId}] ${bind}`);
-  });
-
-  console.log(` - peripherals:                    ${peripherals?.length || 0}`);
-  peripherals?.forEach(({ name, peripheralId: id, vendor }) => {
-    console.log(`   - [${id}] ${name} (${vendor})`);
-  });
-
-  if (configuration) {
-    const { nodes } = configuration;
-    console.log(` - configuration:`);
-    console.log(`   - nodes:                        ${nodes?.length || 0}`);
-    nodes?.forEach(({ id, type }) => {
-      console.log(`     - [${id}] (${getName(synapse.NodeType, type)})`);
-    });
-  }
-
-  return true;
-};
-
-const read = async (device: Device, argv: any) => {
-  console.log("Reading from device's StreamOut node...");
-
-  const { udpPort, output } = argv;
-  let status = null;
-  let stream = null;
-  if (output) {
-    console.log(`Writing to file: ${output}`);
-    stream = fs.createWriteStream(output);
-  }
-
-  const onMessage = (msg: Buffer) => {
-    const value = msg.readUInt32BE();
-    console.log(`StreamOut | recv: ${value}`);
-    if (stream) {
-      stream.write(msg);
-    }
-  };
-
-  const config = new Config();
-  const nodeEphys = new ElectricalBroadband({
-    peripheralId: 100,
-    signal: {
-      electrode: {
-        channels: [{ id: 0, referenceId: 0, electrodeId: 1 }],
-      },
-    },
-    bitWidth: 12,
-    sampleRateHz: 16000,
-  });
-  const nodeStreamOut = new StreamOut(
-    {
-      udpUnicast: {
-        destinationPort: udpPort,
-        destinationAddress: await getClientIp(),
-      },
-    },
-    { onMessage }
-  );
-
-  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...");
-  status = await device.configure(config);
-  if (!status.ok()) {
-    console.error("failed to configure device: ", status.message);
-    return;
-  }
-
-  console.log("Starting device...");
-  status = await device.start();
-  if (!status.ok()) {
-    console.error("failed to start device: ", status.message);
-    return;
-  }
-
-  status = await nodeStreamOut.start();
-  if (!status.ok()) {
-    console.error("failed to start stream out node: ", status.message);
-    return;
-  }
-
-  let running = true;
-  process.on("SIGINT", function () {
-    if (!running) {
-      return;
-    }
-
-    running = false;
-    nodeStreamOut.stop();
-    device.stop();
-    process.exit();
-  });
-};
-
-const write = async (device: Device, argv: any) => {
-  const { input } = argv;
-
-  if (input && !fs.existsSync(input)) {
-    console.error(`File not found: ${input}`);
-    return;
-  }
-
-  console.log("Writing to device's StreamOut node...");
-  let status = null;
-
-  const config = new Config();
-  const nodeStreamIn = new StreamIn({
-    dataType: synapse.DataType.kBroadband,
-  });
-  const nodeOptical = new OpticalStimulation();
-
-  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...");
-  status = await device.configure(config);
-  if (!status.ok()) {
-    console.error("Failed to configure device: ", status.message);
-    return;
-  }
-
-  console.log("Starting device...");
-  status = await device.start();
-  if (!status.ok()) {
-    console.error("Failed to start device: ", status.message);
-    return;
-  }
-
-  let running = true;
-  process.on("SIGINT", function () {
-    console.log("SIGINT", running);
-    if (!running) return;
-    console.log("stopping...");
-
-    running = false;
-    device.stop();
-
-    process.exit();
-  });
-
-  if (input) {
-    console.log(`Reading from file: ${input}`);
-    fs.open(input, "r", (err, fd) => {
-      console.log("Opened file");
-      const kBufSize = 4;
-      const buffer = Buffer.alloc(kBufSize);
-
-      if (err) {
-        console.error(err);
-        return;
-      }
-
-      const read = () => {
-        if (!running) {
-          fs.close(fd, () => {});
-          return;
-        }
-
-        fs.read(fd, buffer, 0, kBufSize, null, (err, n) => {
-          if (err) {
-            console.error(err);
-            return;
-          }
-
-          if (n === 0) {
-            return;
-          }
-
-          console.log(`StreamIn | send: ${buffer.readUInt32BE()}`);
-          nodeStreamIn.write(buffer.slice(0, n));
-          read();
-        });
-      };
-
-      read();
-    });
-
-    return;
-  }
-
-  let i = 0;
-  const kInterval = 1;
-  const buffer = Buffer.alloc(4);
-  const write = () => {
-    if (!running) {
-      device.stop();
-      return;
-    }
-
-    buffer.writeUInt32BE(i++);
-    nodeStreamIn.write(buffer);
-
-    setTimeout(write, kInterval);
-  };
-  setTimeout(write, kInterval);
-};
-
-const main = async () => {
-  const argv = cli.parseSync();
-
-  if (argv._.includes("discover")) {
-    const devices = await discover();
-    for (const device of devices) {
-      const addr = `${device.host}:${device.port}`;
-      const serial = `[${device.serial}]`;
-      console.log(`${addr.padEnd(21)} ${device.capability.padStart(16)} ${serial.padStart(34)} "${device.name}"`);
-    }
-    return;
-  }
-
-  const { uri } = argv;
-  if (!uri) {
-    console.error("Missing URI");
-    return;
-  }
-
-  console.log(`Connecting to device @ ${uri}`);
-  const device = new Device(uri as string);
-
-  try {
-    await info(device);
-  } catch (err) {
-    console.error(`Failed to get device info (${err.code}): ${err.message}`);
-    return;
-  }
-
-  if (argv._.includes("read")) {
-    return read(device, argv);
-  }
-
-  if (argv._.includes("write")) {
-    return write(device, argv);
-  }
-};
-
-main();

package/src/nodes/stream_in.ts

@@ -1,78 +0,0 @@
-import dgram from "dgram";
-
-import { synapse } from "../api/api";
-import Node from "../node";
-
-class StreamIn extends Node {
-  type = synapse.NodeType.kStreamIn;
-  config: synapse.IStreamInConfig;
-  _socket: dgram.Socket;
-
-  constructor(config: synapse.IStreamInConfig = {}) {
-    super();
-    this.config = config;
-  }
-
-  write(data: string | Buffer): boolean {
-    if (this.device === null) {
-      return false;
-    }
-
-    const socket = this.device.sockets.find((s) => s.nodeId === this.id);
-    if (!socket) {
-      return false;
-    }
-
-    const split = socket.bind.split(":");
-    if (split.length !== 2) {
-      return false;
-    }
-
-    const port = parseInt(split[1]);
-    if (isNaN(port)) {
-      return false;
-    }
-
-    const host = split[0];
-    if (!host || !port) {
-      return false;
-    }
-
-    if (!this._socket) {
-      this._socket = dgram.createSocket("udp4");
-    }
-
-    try {
-      this._socket.send(data, port, host);
-    } catch {
-      return false;
-    }
-
-    return true;
-  }
-
-  toProto(): synapse.NodeConfig {
-    return super.toProto({
-      streamIn: this.config,
-    });
-  }
-
-  _getAddr = (): string | null => {
-    if (this.device === null) {
-      return null;
-    }
-
-    return this.device.uri.split(":")[0];
-  };
-
-  static fromProto(proto: synapse.INodeConfig): StreamIn {
-    const { streamIn } = proto;
-    if (!streamIn) {
-      throw new Error("Invalid config, missing streamIn");
-    }
-
-    return new StreamIn(streamIn);
-  }
-}
-
-export default StreamIn;

package/src/nodes/stream_out.ts

@@ -1,109 +0,0 @@
-import dgram from "dgram";
-
-import { synapse } from "../api/api";
-import Node from "../node";
-import { Status, StatusCode } from "../utils/status";
-import { getClientIp } from "../utils/ip";
-
-const kDefaultStreamOutPort = 50038;
-const kSocketBufferSize = 5 * 1024 * 1024; // 5MB
-
-class StreamOut extends Node {
-  type = synapse.NodeType.kStreamOut;
-  _destinationAddress: string;
-  _destinationPort: number;
-  _label: string;
-  _socket: dgram.Socket | null;
-  _onMessage: ((msg: Buffer) => void) | null;
-  _onError: ((error: Error) => void) | null;
-
-  constructor(
-    config: synapse.IStreamOutConfig,
-    callbacks?: { onMessage?: (msg: Buffer) => void; onError?: (error: Error) => void }
-  ) {
-    super();
-
-    const { udpUnicast } = config || {};
-    this._destinationAddress = udpUnicast?.destinationAddress;
-    this._destinationPort = udpUnicast?.destinationPort || kDefaultStreamOutPort;
-    this._label = config.label;
-    this._onMessage = callbacks?.onMessage;
-    this._onError = callbacks?.onError;
-  }
-
-  async start(): Promise<Status> {
-    try {
-      this._socket = dgram.createSocket("udp4");
-
-      if (!this._destinationAddress) {
-        try {
-          const ip = await getClientIp();
-          if (!ip) {
-            return new Status(StatusCode.INTERNAL, "failed to get client ip");
-          }
-          this._destinationAddress = ip;
-        } catch (e) {
-          console.error(e);
-          return new Status(StatusCode.INTERNAL, `failed to get client ip: ${e}`);
-        }
-      }
-      if (!this._destinationPort) {
-        this._destinationPort = kDefaultStreamOutPort;
-      }
-
-      this._socket.on("message", (msg: Buffer) => {
-        this._onMessage?.(msg);
-      });
-
-      this._socket.on("error", (error: Error) => {
-        this._onError?.(error);
-      });
-
-      await new Promise<void>((resolve, reject) => {
-        if (!this._socket) return reject(new Error("Socket is null"));
-
-        this._socket.bind(this._destinationPort, this._destinationAddress, () => {
-          this._socket.setRecvBufferSize(kSocketBufferSize);
-          resolve();
-        });
-      });
-
-      return new Status();
-    } catch (e) {
-      return new Status(StatusCode.INTERNAL, `failed to start stream out node: ${e}`);
-    }
-  }
-
-  async stop(): Promise<Status> {
-    if (this._socket) {
-      this._socket.close();
-    }
-
-    return new Status();
-  }
-
-  toProto(): synapse.NodeConfig {
-    const config: synapse.IStreamOutConfig = {
-      label: this._label,
-      udpUnicast: {
-        destinationAddress: this._destinationAddress,
-        destinationPort: this._destinationPort,
-      },
-    };
-
-    return super.toProto({
-      streamOut: config,
-    });
-  }
-
-  static fromProto(proto: synapse.INodeConfig): StreamOut {
-    const { streamOut } = proto;
-    if (!streamOut) {
-      throw new Error("Invalid config, missing streamOut");
-    }
-
-    return new StreamOut(streamOut, undefined);
-  }
-}
-
-export default StreamOut;

package/synapse-api/api/nodes/stream_in.proto

@@ -1,14 +0,0 @@
-syntax = "proto3";
-
-import "api/datatype.proto";
-
-package synapse;
-
-message StreamInConfig {
-  DataType data_type = 1;
-  repeated uint32 shape = 2;
-}
-
-message StreamInStatus {
-  float throughput_mbps = 1;
-}

package/synapse-api/api/nodes/stream_out.proto

@@ -1,42 +0,0 @@
-syntax = "proto3";
-
-package synapse;
-
-/**
- * UDPUnicastConfig defines the configuration parameters for UDP unicast transport.
- */
-message UDPUnicastConfig {
-  // IPv4 or IPv6 address of the destination endpoint
-  string destination_address = 1;
-
-  // Destination port number, 0 to 65535
-  uint32 destination_port = 2;
-}
-
-/**
- * StreamOutConfig defines the configuration for an outbound data stream.
- * Clients can request to create a new outbound stream by providing a transport
- */
-message StreamOutConfig {
-  // Human-readable identifier for the stream
-  string label = 1;
-
-  // Transport-specific configuration
-  // Only one transport type can be specified at a time
-  oneof transport {
-    // Configure for UDP unicast support. Only one destination is supported
-    UDPUnicastConfig udp_unicast = 2;
-  }
-}
-
-/**
- * StreamOutStatus provides status information for an outbound stream.
- * It contains data about the instantaneous performance of the stream
- */
-message StreamOutStatus {
-  // Current throughput of the stream in megabits per second
-  float throughput_mbps = 1;
-
-  // How many failed packet sends have happened since the start of the stream
-  uint64 failed_send_count = 2;
-}