@science-corporation/synapse 0.12.0 → 1.1.0

package/src/nodes/stream_out.ts

@@ -2,80 +2,97 @@ 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 kMulticastTTL = 3;
+const kDefaultStreamOutPort = 50038;
+const kSocketBufferSize = 5 * 1024 * 1024; // 5MB
 
 class StreamOut extends Node {
   type = synapse.NodeType.kStreamOut;
-  config: synapse.IStreamOutConfig;
-  _socket: dgram.Socket;
+  _destinationAddress: string;
+  _destinationPort: number;
+  _label: string;
+  _socket: dgram.Socket | null;
   _onMessage: ((msg: Buffer) => void) | null;
+  _onError: ((error: Error) => void) | null;
 
-  constructor(config: synapse.IStreamOutConfig, onMessage?: (msg: Buffer) => void) {
+  constructor(
+    config: synapse.IStreamOutConfig,
+    callbacks?: { onMessage?: (msg: Buffer) => void; onError?: (error: Error) => void }
+  ) {
     super();
 
-    this.config = config;
-    this._onMessage = onMessage;
+    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<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 = this.config.multicastGroup;
-    if (!host) {
-      return false;
-    }
+  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 = dgram.createSocket("udp4");
+      this._socket.on("message", (msg: Buffer) => {
+        this._onMessage?.(msg);
+      });
 
-    this._socket.on("error", () => {});
+      this._socket.on("error", (error: Error) => {
+        this._onError?.(error);
+      });
 
-    this._socket.on("message", (msg: Buffer) => {
-      this._onMessage?.(msg);
-    });
+      await new Promise<void>((resolve, reject) => {
+        if (!this._socket) return reject(new Error("Socket is null"));
 
-    this._socket.bind(port, host, () => {
-      if (!this._socket) {
-        return;
-      }
+        this._socket.bind(this._destinationPort, this._destinationAddress, () => {
+          this._socket.setRecvBufferSize(kSocketBufferSize);
+          resolve();
+        });
+      });
 
-      if (this.config.multicastGroup) {
-        this._socket.setMulticastTTL(kMulticastTTL);
-        this._socket.addMembership(this.config.multicastGroup);
-      }
-    });
-
-    return true;
+      return new Status();
+    } catch (e) {
+      return new Status(StatusCode.INTERNAL, `failed to start stream out node: ${e}`);
+    }
   }
 
-  async stop(): Promise<boolean> {
+  async stop(): Promise<Status> {
     if (this._socket) {
       this._socket.close();
     }
 
-    return true;
+    return new Status();
   }
 
   toProto(): synapse.NodeConfig {
+    const config: synapse.IStreamOutConfig = {
+      label: this._label,
+      udpUnicast: {
+        destinationAddress: this._destinationAddress,
+        destinationPort: this._destinationPort,
+      },
+    };
+
     return super.toProto({
-      streamOut: this.config,
+      streamOut: config,
     });
   }
 
@@ -85,7 +102,7 @@ class StreamOut extends Node {
       throw new Error("Invalid config, missing streamOut");
     }
 
-    return new StreamOut(streamOut);
+    return new StreamOut(streamOut, undefined);
   }
 }
 

package/src/utils/ip.ts

@@ -0,0 +1,35 @@
+import dgram from "dgram";
+
+export const getClientIp = async (): Promise<string | null> => {
+  return new Promise((resolve, reject) => {
+    try {
+      const socket = dgram.createSocket("udp4");
+
+      socket.on("error", (err) => {
+        console.error(err);
+        socket.close();
+        reject(err);
+      });
+
+      socket.bind(0, () => {
+        try {
+          socket.connect(53, "8.8.8.8", () => {
+            try {
+              const address = socket.address();
+              socket.close();
+              resolve(address.address);
+            } catch (e) {
+              socket.close();
+              reject(e);
+            }
+          });
+        } catch (e) {
+          socket.close();
+          reject(e);
+        }
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+};

package/synapse-api/README.md

@@ -1,4 +1,4 @@
-# Synapse API 1.1
+# Synapse API 2.0.0
 
 The Synapse Protocol defines a standard interface for interacting with a wide range of possible neural interface devices.
 

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

@@ -2,11 +2,41 @@ 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;
-  string multicast_group = 2;
+
+  // 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;
 }

package/dist/api-science-device/api.d.ts

@@ -1,3 +0,0 @@
-declare const _exports: any;
-export = _exports;
-//# sourceMappingURL=api.d.ts.map

package/dist/api-science-device/api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api-science-device/api.js"],"names":[],"mappings":""}