@synnaxlabs/client 0.40.0 → 0.42.0

package/src/framer/streamer.ts

@@ -7,32 +7,73 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { EOF, errorZ, type Stream, type StreamClient } from "@synnaxlabs/freighter";
-import { observe } from "@synnaxlabs/x";
+import { EOF, type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
+import { breaker, observe, TimeSpan } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
 import { ReadAdapter } from "@/framer/adapter";
+import { WSStreamerCodec } from "@/framer/codec";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
-const reqZ = z.object({ keys: z.number().array(), downsampleFactor: z.number() });
+const reqZ = z.object({ keys: z.number().array(), downSampleFactor: z.number() });
 
-const resZ = z.object({ frame: frameZ, error: errorZ.optional().nullable() });
+export type StreamerRequest = z.infer<typeof reqZ>;
+
+const resZ = z.object({ frame: frameZ });
+
+export type StreamerResponse = z.infer<typeof resZ>;
 
 const ENDPOINT = "/frame/stream";
 
 export interface StreamerConfig {
   channels: channel.Params;
-  downsampleFactor?: number;
+  downSampleFactor?: number;
+  useExperimentalCodec?: boolean;
+}
+
+export interface Streamer extends AsyncIterator<Frame>, AsyncIterable<Frame> {
+  keys: channel.Key[];
+  update: (channels: channel.Params) => Promise<void>;
+  close: () => void;
+  read: () => Promise<Frame>;
 }
 
-export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
+export interface StreamOpener {
+  (config: StreamerConfig | channel.Params): Promise<Streamer>;
+}
+
+export const createStreamOpener =
+  (retriever: channel.Retriever, client: WebSocketClient): StreamOpener =>
+  async (config) => {
+    let cfg: StreamerConfig;
+    if (Array.isArray(config) || typeof config !== "object")
+      cfg = { channels: config as channel.Params, downSampleFactor: 1 };
+    else cfg = config as StreamerConfig;
+    const adapter = await ReadAdapter.open(retriever, cfg.channels);
+    if (cfg.useExperimentalCodec)
+      client = client.withCodec(new WSStreamerCodec(adapter.codec));
+    const stream = await client.stream(ENDPOINT, reqZ, resZ);
+    const streamer = new CoreStreamer(stream, adapter);
+    stream.send({ keys: adapter.keys, downSampleFactor: cfg.downSampleFactor ?? 1 });
+    const [, err] = await stream.receive();
+    if (err != null) throw err;
+    return streamer;
+  };
+
+export const openStreamer = async (
+  retriever: channel.Retriever,
+  client: WebSocketClient,
+  config: StreamerConfig,
+): Promise<Streamer> => await createStreamOpener(retriever, client)(config);
+
+class CoreStreamer implements Streamer {
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
   private readonly adapter: ReadAdapter;
   private readonly downsampleFactor: number;
 
-  private constructor(stream: Stream<typeof reqZ, typeof resZ>, adapter: ReadAdapter) {
+  constructor(stream: Stream<typeof reqZ, typeof resZ>, adapter: ReadAdapter) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
     this.downsampleFactor = 1;
@@ -42,20 +83,6 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     return this.adapter.keys;
   }
 
-  static async _open(
-    retriever: channel.Retriever,
-    client: StreamClient,
-    { channels, downsampleFactor }: StreamerConfig,
-  ): Promise<Streamer> {
-    const adapter = await ReadAdapter.open(retriever, channels);
-    const stream = await client.stream(ENDPOINT, reqZ, resZ);
-    const streamer = new Streamer(stream, adapter);
-    stream.send({ keys: adapter.keys, downsampleFactor: downsampleFactor ?? 1 });
-    const [, err] = await stream.receive();
-    if (err != null) throw err;
-    return streamer;
-  }
-
   async next(): Promise<IteratorResult<Frame, any>> {
     try {
       const frame = await this.read();
@@ -74,7 +101,7 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     await this.adapter.update(channels);
     this.stream.send({
       keys: this.adapter.keys,
-      downsampleFactor: this.downsampleFactor,
+      downSampleFactor: this.downsampleFactor,
     });
   }
 
@@ -87,6 +114,95 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
   }
 }
 
+export class HardenedStreamer implements Streamer {
+  private wrapped_: Streamer | null = null;
+  private readonly breaker: breaker.Breaker;
+  private readonly opener: StreamOpener;
+  private readonly config: StreamerConfig;
+
+  private constructor(opener: StreamOpener, config: StreamerConfig | channel.Params) {
+    this.opener = opener;
+    if (Array.isArray(config) || typeof config !== "object")
+      this.config = { channels: config as channel.Params, downSampleFactor: 1 };
+    else this.config = config as StreamerConfig;
+    this.breaker = new breaker.Breaker({
+      maxRetries: 5000,
+      baseInterval: TimeSpan.seconds(1),
+      scale: 1,
+    });
+  }
+
+  static async open(
+    opener: StreamOpener,
+    config: StreamerConfig | channel.Params,
+  ): Promise<HardenedStreamer> {
+    const h = new HardenedStreamer(opener, config);
+    await h.runStreamer();
+    return h;
+  }
+
+  private async runStreamer(): Promise<void> {
+    while (true)
+      try {
+        if (this.wrapped_ != null) this.wrapped_.close();
+        this.wrapped_ = await this.opener(this.config);
+        this.breaker.reset();
+        return;
+      } catch (e) {
+        this.wrapped_ = null;
+        if (!(await this.breaker.wait())) throw e;
+        continue;
+      }
+  }
+
+  private get wrapped(): Streamer {
+    if (this.wrapped_ == null) throw new Error("stream closed");
+    return this.wrapped_;
+  }
+
+  async update(channels: channel.Params): Promise<void> {
+    this.config.channels = channels;
+    try {
+      await this.wrapped.update(channels);
+    } catch {
+      await this.runStreamer();
+      return await this.update(channels);
+    }
+  }
+
+  async next(): Promise<IteratorResult<Frame>> {
+    try {
+      return { done: false, value: await this.read() };
+    } catch (e) {
+      if (EOF.matches(e)) return { done: true, value: undefined };
+      throw e;
+    }
+  }
+
+  async read(): Promise<Frame> {
+    try {
+      const fr = await this.wrapped.read();
+      this.breaker.reset();
+      return fr;
+    } catch (e) {
+      if (EOF.matches(e)) throw e;
+      await this.runStreamer();
+      return await this.read();
+    }
+  }
+  close(): void {
+    this.wrapped.close();
+  }
+
+  get keys(): channel.Key[] {
+    return this.wrapped.keys;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<Frame> {
+    return this;
+  }
+}
+
 export class ObservableStreamer<V = Frame>
   extends observe.Observer<Frame, V>
   implements observe.ObservableAsyncCloseable<V>

package/src/framer/writer.spec.ts

@@ -7,33 +7,29 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { id } from "@synnaxlabs/x";
-import { DataType, Rate, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
-import { describe, expect, test } from "vitest";
+import { DataType, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
+import { describe, expect, it, test } from "vitest";
 
-import { type channel } from "@/channel";
 import { UnauthorizedError, ValidationError } from "@/errors";
 import { ALWAYS_INDEX_PERSIST_ON_AUTO_COMMIT, WriterMode } from "@/framer/writer";
 import { newClient } from "@/setupspecs";
+import { newIndexedPair } from "@/testutil/indexedPair";
+import { secondsLinspace } from "@/testutil/telem";
 import { randomSeries } from "@/util/telem";
 
 const client = newClient();
-
-const newChannel = async (): Promise<channel.Channel> =>
-  await client.channels.create({
-    leaseholder: 1,
-    name: `test-${id.create()}`,
-    rate: Rate.hz(1),
-    dataType: DataType.FLOAT64,
-  });
-
 describe("Writer", () => {
   describe("Writer", () => {
     test("basic write", async () => {
-      const ch = await newChannel();
-      const writer = await client.openWriter({ start: 0, channels: ch.key });
+      const channels = await newIndexedPair(client);
+      const start = TimeStamp.seconds(1);
+      const writer = await client.openWriter({ start, channels });
+      const [index, data] = channels;
       try {
-        await writer.write(ch.key, randomSeries(10, ch.dataType));
+        await writer.write({
+          [index.key]: secondsLinspace(1, 10),
+          [data.key]: randomSeries(10, data.dataType),
+        });
         await writer.commit();
       } finally {
         await writer.close();
@@ -42,24 +38,28 @@ describe("Writer", () => {
     });
 
     test("write to unknown channel key", async () => {
-      const ch = await newChannel();
-      const writer = await client.openWriter({ start: 0, channels: ch.key });
+      const channels = await newIndexedPair(client);
+      const writer = await client.openWriter({ start: TimeStamp.now(), channels });
       await expect(
         writer.write("billy bob", randomSeries(10, DataType.FLOAT64)),
-      ).rejects.toThrow("Channel billy bob not found");
+      ).rejects.toThrow('Channel "billy bob" not found');
       await writer.close();
     });
 
-    test("stream when mode is set ot persist only", async () => {
-      const ch = await newChannel();
-      const stream = await client.openStreamer(ch.key);
+    it("should not stream data when mode is set ot persist only", async () => {
+      const channels = await newIndexedPair(client);
+      const stream = await client.openStreamer(channels);
       const writer = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start: TimeStamp.seconds(1),
+        channels,
         mode: WriterMode.Persist,
       });
+      const [index, data] = channels;
       try {
-        await writer.write(ch.key, randomSeries(10, ch.dataType));
+        await writer.write({
+          [index.key]: secondsLinspace(1, 10),
+          [data.key]: randomSeries(10, data.dataType),
+        });
       } finally {
         await writer.close();
       }
@@ -72,33 +72,44 @@ describe("Writer", () => {
     });
 
     test("write with auto commit on", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
       const writer = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start: TimeStamp.seconds(1),
+        channels,
         enableAutoCommit: true,
       });
+      const [index, data] = channels;
       try {
-        await writer.write(ch.key, randomSeries(10, ch.dataType));
+        await writer.write({
+          [index.key]: secondsLinspace(1, 10),
+          [data.key]: randomSeries(10, data.dataType),
+        });
       } finally {
         await writer.close();
       }
       expect(true).toBeTruthy();
 
-      const f = await client.read(new TimeRange(0, TimeStamp.seconds(10)), ch.key);
+      const f = await client.read(
+        new TimeRange(TimeStamp.seconds(1), TimeStamp.seconds(11)),
+        index.key,
+      );
       expect(f.length).toEqual(10);
     });
 
     test("write with auto commit and alwaysPersist", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
       const writer = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start: TimeStamp.seconds(1),
+        channels,
         enableAutoCommit: true,
         autoIndexPersistInterval: ALWAYS_INDEX_PERSIST_ON_AUTO_COMMIT,
       });
+      const [index, data] = channels;
       try {
-        await writer.write(ch.key, randomSeries(10, ch.dataType));
+        await writer.write({
+          [index.key]: secondsLinspace(1, 10),
+          [data.key]: randomSeries(10, data.dataType),
+        });
       } finally {
         await writer.close();
       }
@@ -106,21 +117,41 @@ describe("Writer", () => {
     });
 
     test("write with auto commit and a set interval", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
       const writer = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start: TimeStamp.seconds(1),
+        channels,
         enableAutoCommit: true,
         autoIndexPersistInterval: TimeSpan.milliseconds(100),
       });
+      const [index, data] = channels;
       try {
-        await writer.write(ch.key, randomSeries(10, ch.dataType));
+        await writer.write({
+          [index.key]: secondsLinspace(1, 10),
+          [data.key]: randomSeries(10, data.dataType),
+        });
       } finally {
         await writer.close();
       }
       expect(true).toBeTruthy();
     });
 
+    test("write with auto-commit off and incorrect data length validation error", async () => {
+      const channels = await newIndexedPair(client);
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels,
+      });
+      await expect(async () => {
+        await writer.write({
+          [channels[0].key]: secondsLinspace(1, 10),
+          [channels[1].key]: randomSeries(11, channels[1].dataType),
+        });
+        await writer.commit();
+        await writer.close();
+      }).rejects.toThrow(ValidationError);
+    });
+
     test("write with out of order timestamp", async () => {
       const indexCh = await client.channels.create({
         name: "idx",
@@ -140,159 +171,103 @@ describe("Writer", () => {
         enableAutoCommit: true,
       });
 
-      let errAccumulated: boolean = false;
-      for (let i = 0; i < 10; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 5));
-        errAccumulated = !(await writer.write({
-          [indexCh.key]: BigInt(i),
-          [dataCh.key]: i,
-        }));
-        if (errAccumulated) break;
-      }
-
-      expect(errAccumulated).toBeTruthy();
-
-      await expect(writer.close()).rejects.toThrow(ValidationError);
-    });
+      await expect(async () => {
+        for (let i = 0; i < 10; i++) {
+          await new Promise((resolve) => setTimeout(resolve, 5));
+          await writer.write({
+            [indexCh.key]: new TimeStamp(i),
+            [dataCh.key]: i,
+          });
+        }
+      }).rejects.toThrow(ValidationError);
+      await expect(async () => {
+        await writer.close();
+      }).rejects.toThrow(ValidationError);
+    }, 5000000);
 
     test("write with errOnUnauthorized", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
       const w1 = await client.openWriter({
         start: new TimeStamp(TimeSpan.milliseconds(500)),
-        channels: ch.key,
+        channels,
       });
 
       await expect(
-        client.openWriter({ start: 0, channels: ch.key, errOnUnauthorized: true }),
+        client.openWriter({
+          start: TimeStamp.now(),
+          channels,
+          errOnUnauthorized: true,
+        }),
       ).rejects.toThrow(UnauthorizedError);
       await w1.close();
     });
 
     test("setAuthority", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
+      const start = TimeStamp.seconds(5);
       const w1 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start,
+        channels,
         authorities: 10,
         enableAutoCommit: true,
       });
       const w2 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start,
+        channels,
         authorities: 20,
         enableAutoCommit: true,
       });
-
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-      let f = await ch.read(TimeRange.MAX);
+      const [index, data] = channels;
+      await w1.write({
+        [index.key]: secondsLinspace(5, 10),
+        [data.key]: randomSeries(10, data.dataType),
+      });
+      let f = await index.read(TimeRange.MAX);
       expect(f.length).toEqual(0);
 
-      await w1.setAuthority({ [ch.key]: 100 });
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-
-      f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(10);
-
+      await w1.setAuthority(100);
+      await w1.write({
+        [index.key]: secondsLinspace(5, 10),
+        [data.key]: randomSeries(10, data.dataType),
+      });
       await w1.close();
       await w2.close();
+      f = await index.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
     });
 
     test("setAuthority with name keys", async () => {
-      const ch = await newChannel();
+      const channels = await newIndexedPair(client);
+      const start = TimeStamp.seconds(5);
       const w1 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start,
+        channels,
         authorities: 10,
         enableAutoCommit: true,
       });
       const w2 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
+        start,
+        channels,
         authorities: 20,
         enableAutoCommit: true,
       });
-
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-      let f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(0);
-
-      await w1.setAuthority({ [ch.name]: 100 });
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-
-      f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(10);
-
-      await w1.close();
-      await w2.close();
-    });
-
-    test("setAuthority with name-value pair", async () => {
-      const ch = await newChannel();
-      const w1 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
-        authorities: 10,
-        enableAutoCommit: true,
-      });
-      const w2 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
-        authorities: 20,
-        enableAutoCommit: true,
+      const [index, data] = channels;
+      await w1.write({
+        [index.key]: secondsLinspace(5, 10),
+        [data.key]: randomSeries(10, data.dataType),
       });
-
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-      let f = await ch.read(TimeRange.MAX);
+      let f = await index.read(TimeRange.MAX);
       expect(f.length).toEqual(0);
 
-      await w1.setAuthority(ch.name, 100);
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-
-      f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(10);
-
-      await w1.close();
-      await w2.close();
-    });
-
-    test("setAuthority on all channels", async () => {
-      const ch = await newChannel();
-      const w1 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
-        authorities: 10,
-        enableAutoCommit: true,
-      });
-      const w2 = await client.openWriter({
-        start: 0,
-        channels: ch.key,
-        authorities: 20,
-        enableAutoCommit: true,
+      await w1.setAuthority({ [index.name]: 100, [data.name]: 100 });
+      await w1.write({
+        [index.key]: secondsLinspace(5, 10),
+        [data.key]: randomSeries(10, data.dataType),
       });
-
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-      let f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(0);
-
-      await w1.setAuthority(ch.name, 255);
-      await w1.write(ch.key, randomSeries(10, ch.dataType));
-
-      f = await ch.read(TimeRange.MAX);
-      expect(f.length).toEqual(10);
-
       await w1.close();
       await w2.close();
-    });
-  });
-
-  describe("Client", () => {
-    test("Client - basic write", async () => {
-      const ch = await newChannel();
-      const data = randomSeries(10, ch.dataType);
-      await client.write(TimeStamp.seconds(1), ch.key, data);
-      const res = await client.read(TimeRange.MAX, ch.key);
-      expect(res.length).toEqual(data.length);
-      expect(res.data).toEqual(data);
+      f = await index.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
     });
   });
 });