@camera.ui/rpc 1.0.3 → 1.0.4

package/externals/nats.js/core/src/servers.ts

@@ -0,0 +1,424 @@
+/*
+ * Copyright 2018-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { getUrlParseFn } from "./transport.ts";
+import { shuffle } from "./util.ts";
+import { isIP } from "./ipparser.ts";
+import type {
+  DnsResolveFn,
+  Server,
+  ServerInfo,
+  ServersChanged,
+} from "./core.ts";
+import { DEFAULT_PORT } from "./core.ts";
+import { InvalidArgumentError } from "./errors.ts";
+
+export function isIPV4OrHostname(hp: string): boolean {
+  // in the wild seeing IPv4s as IPv6s
+  // ::ffff:35.234.43.228 which incorrectly get mapped to IPv4 unless
+  // we add this test first
+  if (hp.indexOf("[") !== -1 || hp.indexOf("::") !== -1) {
+    return false;
+  }
+  if (hp.indexOf(".") !== -1) {
+    return true;
+  }
+  // if we have a plain hostname or host:port
+  if (hp.split(":").length <= 2) {
+    return true;
+  }
+  return false;
+}
+
+function isIPV6(hp: string) {
+  return !isIPV4OrHostname(hp);
+}
+
+function filterIpv6MappedToIpv4(hp: string): string {
+  const prefix = "::FFFF:";
+  const idx = hp.toUpperCase().indexOf(prefix);
+  if (idx !== -1 && hp.indexOf(".") !== -1) {
+    // we have something like: ::FFFF:127.0.0.1 or [::FFFF:127.0.0.1]:4222
+    let ip = hp.substring(idx + prefix.length);
+    ip = ip.replace("[", "");
+    return ip.replace("]", "");
+  }
+
+  return hp;
+}
+
+export function hostPort(
+  u: string,
+): { listen: string; hostname: string; port: number } {
+  u = u.trim();
+  // remove any protocol that may have been provided
+  if (u.match(/^(.*:\/\/)(.*)/m)) {
+    u = u.replace(/^(.*:\/\/)(.*)/gm, "$2");
+  }
+  // in web environments, URL may not be a living standard
+  // that means that protocols other than HTTP/S are not
+  // parsable correctly.
+
+  // the third complication is that we may have been given
+  // an IPv6 or worse IPv6 mapping an Ipv4
+  u = filterIpv6MappedToIpv4(u);
+
+  // we only wrap cases where they gave us a plain ipv6
+  // and we are not already bracketed
+  if (isIPV6(u) && u.indexOf("[") === -1) {
+    u = `[${u}]`;
+  }
+  // if we have ipv6, we expect port after ']:' otherwise after ':'
+  const op = isIPV6(u) ? u.match(/(]:)(\d+)/) : u.match(/(:)(\d+)/);
+  const port = op && op.length === 3 && op[1] && op[2]
+    ? parseInt(op[2])
+    : DEFAULT_PORT;
+
+  // the next complication is that new URL() may
+  // eat ports which match the protocol - so for example
+  // port 80 may be eliminated - so we flip the protocol
+  // so that it always yields a value
+  const protocol = port === 80 ? "https" : "http";
+  const url = new URL(`${protocol}://${u}`);
+  url.port = `${port}`;
+
+  let hostname = url.hostname;
+  // if we are bracketed, we need to rip it out
+  if (hostname.charAt(0) === "[") {
+    hostname = hostname.substring(1, hostname.length - 1);
+  }
+  const listen = url.host;
+
+  return { listen, hostname, port };
+}
+
+/**
+ * @hidden
+ */
+export class ServerImpl implements Server {
+  src: string;
+  listen: string;
+  hostname: string;
+  port: number;
+  didConnect: boolean;
+  reconnects: number;
+  lastConnect: number;
+  gossiped: boolean;
+  tlsName: string;
+  resolves?: Server[];
+
+  constructor(u: string, gossiped = false) {
+    this.src = u;
+    this.tlsName = "";
+    const v = hostPort(u);
+    this.listen = v.listen;
+    this.hostname = v.hostname;
+    this.port = v.port;
+    this.didConnect = false;
+    this.reconnects = 0;
+    this.lastConnect = 0;
+    this.gossiped = gossiped;
+  }
+
+  toString(): string {
+    return this.listen;
+  }
+
+  async resolve(
+    opts: Partial<
+      {
+        fn: DnsResolveFn;
+        randomize: boolean;
+        resolve: boolean;
+        debug: boolean;
+      }
+    >,
+  ): Promise<Server[]> {
+    if (!opts.fn || opts.resolve === false) {
+      // we cannot resolve - transport doesn't support it
+      // or user opted out
+      // don't add - to resolves or we get a circ reference
+      return [this];
+    }
+
+    const buf: Server[] = [];
+    if (isIP(this.hostname)) {
+      // don't add - to resolves or we get a circ reference
+      return [this];
+    } else {
+      // resolve the hostname to ips
+      const ips = await opts.fn(this.hostname);
+      if (opts.debug) {
+        console.log(`resolve ${this.hostname} = ${ips.join(",")}`);
+      }
+
+      for (const ip of ips) {
+        // letting URL handle the details of representing IPV6 ip with a port, etc
+        // careful to make sure the protocol doesn't line with standard ports or they
+        // get swallowed
+        const proto = this.port === 80 ? "https" : "http";
+        // ipv6 won't be bracketed here, because it came from resolve
+        const url = new URL(`${proto}://${isIPV6(ip) ? "[" + ip + "]" : ip}`);
+        url.port = `${this.port}`;
+        const ss = new ServerImpl(url.host, false);
+        ss.tlsName = this.hostname;
+        buf.push(ss);
+      }
+    }
+    if (opts.randomize) {
+      shuffle(buf);
+    }
+    this.resolves = buf;
+    return buf;
+  }
+}
+
+/**
+ * @hidden
+ */
+export class Servers {
+  private firstSelect: boolean;
+  private servers: ServerImpl[];
+  private currentServer!: ServerImpl;
+  private tlsName: string;
+  private randomize: boolean;
+
+  constructor(opts: Partial<{ randomize: boolean }> = {}) {
+    this.firstSelect = true;
+    this.servers = [];
+    this.tlsName = "";
+    this.randomize = opts.randomize || false;
+  }
+
+  /**
+   * Replace the server pool with the provided list of `host:port` entries.
+   *
+   * Throws `InvalidArgumentError` if `listens` is empty or not an array.
+   *
+   * Note: reconnect attempts continue to follow the configured reconnect
+   * policy, but if every entry in the new pool is unreachable the
+   * connection may be left unable to recover.
+   */
+  setServers(listens: string[]): void {
+    if (!Array.isArray(listens) || listens.length === 0) {
+      throw InvalidArgumentError.format("servers", "cannot be empty");
+    }
+    const urlParseFn = getUrlParseFn();
+    const existing = new Map<string, ServerImpl>();
+    for (const s of this.servers) existing.set(s.listen, s);
+
+    const merged: ServerImpl[] = [];
+    for (let hp of listens) {
+      hp = urlParseFn ? urlParseFn(hp) : hp;
+      const { listen } = hostPort(hp);
+      const surviving = existing.get(listen);
+      if (surviving) {
+        // user-supplied = not gossiped. otherwise a later cluster update()
+        // could remove an entry the user explicitly asked for.
+        surviving.gossiped = false;
+        // camera.ui fork patch.
+        // `existing.get(listen)` keys only on `host:port`, so a re-issued
+        // URL that differs only in its query string (e.g., a rotated auth
+        // token in `?token=…`) would be silently dropped — the recycled
+        // ServerImpl still carries the OLD `src`, and the next reconnect
+        // would dial that stale URL. Update `src` in place so the new query
+        // is what gets used by the WS transport on the next dial.
+        if (surviving.src !== hp) {
+          surviving.src = hp;
+        }
+        merged.push(surviving);
+      } else {
+        merged.push(new ServerImpl(hp));
+      }
+    }
+    if (this.randomize) shuffle(merged);
+
+    this.servers = merged;
+    if (
+      this.currentServer === undefined ||
+      !merged.includes(this.currentServer)
+    ) {
+      this.currentServer = merged[0];
+      this.firstSelect = true;
+    }
+  }
+
+  clear(): void {
+    this.servers.length = 0;
+  }
+
+  updateTLSName(): void {
+    const cs = this.getCurrentServer();
+    if (!isIP(cs.hostname)) {
+      this.tlsName = cs.hostname;
+      this.servers.forEach((s) => {
+        if (s.gossiped) {
+          s.tlsName = this.tlsName;
+        }
+      });
+    }
+  }
+
+  getCurrentServer(): ServerImpl {
+    return this.currentServer;
+  }
+
+  addServer(u: string, implicit = false): void {
+    const urlParseFn = getUrlParseFn();
+    u = urlParseFn ? urlParseFn(u) : u;
+    const s = new ServerImpl(u, implicit);
+    if (isIP(s.hostname)) {
+      s.tlsName = this.tlsName;
+    }
+    this.servers.push(s);
+  }
+
+  selectServer(): ServerImpl | undefined {
+    // allow using select without breaking the order of the servers
+    if (this.firstSelect) {
+      this.firstSelect = false;
+      return this.currentServer;
+    }
+    const t = this.servers.shift();
+    if (t) {
+      this.servers.push(t);
+      this.currentServer = t;
+    }
+    return t;
+  }
+
+  removeCurrentServer(): void {
+    this.removeServer(this.currentServer);
+  }
+
+  removeServer(server: ServerImpl | undefined): void {
+    if (server) {
+      const index = this.servers.indexOf(server);
+      this.servers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Returns a frozen snapshot of the server pool in natural order.
+   * Each entry is a defensive copy — callers cannot mutate pool state.
+   */
+  snapshot(): ReadonlyArray<Server> {
+    return Servers.freezeAll(this.servers);
+  }
+
+  /**
+   * Returns a frozen snapshot of the server pool with the current server
+   * (= next dial candidate) at index 0. Used to present the handler with
+   * the server the library would have selected.
+   */
+  snapshotForHandler(): ReadonlyArray<Server> {
+    const cur = this.currentServer;
+    if (!cur) return this.snapshot();
+    const idx = this.servers.indexOf(cur);
+    if (idx <= 0) return this.snapshot();
+    return Servers.freezeAll(
+      [cur, ...this.servers.slice(0, idx), ...this.servers.slice(idx + 1)],
+    );
+  }
+
+  private static freezeAll(arr: ServerImpl[]): ReadonlyArray<Server> {
+    return arr.map((s) =>
+      Object.freeze<Server>({
+        hostname: s.hostname,
+        port: s.port,
+        listen: s.listen,
+        src: s.src,
+        tlsName: s.tlsName,
+        reconnects: s.reconnects,
+        lastConnect: s.lastConnect,
+        gossiped: s.gossiped,
+        didConnect: s.didConnect,
+      })
+    );
+  }
+
+  find(server: Server): ServerImpl | undefined {
+    return this.servers.find((s) => s.listen === server.listen);
+  }
+
+  setCurrent(server: ServerImpl): void {
+    this.currentServer = server;
+  }
+
+  length(): number {
+    return this.servers.length;
+  }
+
+  next(): ServerImpl | undefined {
+    return this.servers.length ? this.servers[0] : undefined;
+  }
+
+  getServers(): ServerImpl[] {
+    return this.servers;
+  }
+
+  update(info: ServerInfo, encrypted?: boolean): ServersChanged {
+    const added: string[] = [];
+    let deleted: string[] = [];
+
+    const urlParseFn = getUrlParseFn();
+    const discovered = new Map<string, ServerImpl>();
+    if (info.connect_urls && info.connect_urls.length > 0) {
+      info.connect_urls.forEach((hp) => {
+        hp = urlParseFn ? urlParseFn(hp, encrypted) : hp;
+        const s = new ServerImpl(hp, true);
+        discovered.set(hp, s);
+      });
+    }
+    // remove gossiped servers that are no longer reported
+    const toDelete: number[] = [];
+    this.servers.forEach((s, index) => {
+      const u = s.listen;
+      if (
+        s.gossiped && this.currentServer.listen !== u &&
+        discovered.get(u) === undefined
+      ) {
+        // server was removed
+        toDelete.push(index);
+      }
+      // remove this entry from reported
+      discovered.delete(u);
+    });
+
+    // perform the deletion
+    toDelete.reverse();
+    toDelete.forEach((index) => {
+      const removed = this.servers.splice(index, 1);
+      deleted = deleted.concat(removed[0].listen);
+    });
+
+    // remaining servers are new
+    discovered.forEach((v, k) => {
+      this.servers.push(v);
+      added.push(k);
+    });
+
+    // shuffle the pool so reconnect picks distribute across the cluster.
+    // currentServer is held at the head — the live connection isn't
+    // disturbed, but rotation order through the rest is randomized.
+    if (this.randomize && added.length > 0) {
+      const cur = this.currentServer;
+      const others = this.servers.filter((s) => s !== cur);
+      shuffle(others);
+      this.servers = cur ? [cur, ...others] : others;
+    }
+
+    return { added, deleted };
+  }
+}

package/externals/nats.js/core/src/transport.ts

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2020-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { TD } from "./encoders.ts";
+
+import type {
+  ConnectionOptions,
+  DnsResolveFn,
+  Server,
+  URLParseFn,
+} from "./core.ts";
+
+import { DEFAULT_PORT } from "./core.ts";
+import { DataBuffer } from "./databuffer.ts";
+
+let transportConfig: TransportFactory;
+export function setTransportFactory(config: TransportFactory): void {
+  transportConfig = config;
+}
+
+export function defaultPort(): number {
+  return transportConfig !== undefined &&
+      transportConfig.defaultPort !== undefined
+    ? transportConfig.defaultPort
+    : DEFAULT_PORT;
+}
+
+export function getUrlParseFn(): URLParseFn | undefined {
+  return transportConfig !== undefined && transportConfig.urlParseFn
+    ? transportConfig.urlParseFn
+    : undefined;
+}
+
+export function newTransport(): Transport {
+  if (!transportConfig || typeof transportConfig.factory !== "function") {
+    throw new Error("transport fn is not set");
+  }
+  return transportConfig.factory();
+}
+
+export function getResolveFn(): DnsResolveFn | undefined {
+  return transportConfig !== undefined && transportConfig.dnsResolveFn
+    ? transportConfig.dnsResolveFn
+    : undefined;
+}
+
+export interface TransportFactory {
+  factory?: () => Transport;
+  defaultPort?: number;
+  urlParseFn?: URLParseFn;
+  dnsResolveFn?: DnsResolveFn;
+}
+
+export interface Transport extends AsyncIterable<Uint8Array> {
+  readonly isClosed: boolean;
+  readonly lang: string;
+  readonly version: string;
+  readonly closeError?: Error;
+
+  connect(
+    server: Server,
+    opts: ConnectionOptions,
+  ): Promise<void>;
+
+  [Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array>;
+
+  isEncrypted(): boolean;
+
+  send(frame: Uint8Array): void;
+
+  close(err?: Error): Promise<void>;
+
+  disconnect(): void;
+
+  closed(): Promise<void | Error>;
+
+  // this is here for websocket implementations as some implementations
+  // (firefox) throttle connections that then resolve later
+  discard(): void;
+}
+
+export const CR_LF = "\r\n";
+export const CR_LF_LEN = CR_LF.length;
+export const CRLF = DataBuffer.fromAscii(CR_LF);
+export const CR = new Uint8Array(CRLF)[0]; // 13
+export const LF = new Uint8Array(CRLF)[1]; // 10
+export function protoLen(ba: Uint8Array): number {
+  for (let i = 0; i < ba.length; i++) {
+    const n = i + 1;
+    if (ba.byteLength > n && ba[i] === CR && ba[n] === LF) {
+      return n + 1;
+    }
+  }
+  return 0;
+}
+
+export function extractProtocolMessage(a: Uint8Array): string {
+  // protocol messages are ascii, so Uint8Array
+  const len = protoLen(a);
+  if (len > 0) {
+    const ba = new Uint8Array(a);
+    const out = ba.slice(0, len);
+    return TD.decode(out);
+  }
+  return "";
+}

package/externals/nats.js/core/src/types.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2020-2023 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type { Dispatcher, MsgHdrs, QueuedIterator } from "./core.ts";
+
+export { Empty } from "./encoders.ts";