goscript 0.1.1 → 0.1.2

package/gs/github.com/aperturerobotics/starpc/srpc/index.ts

@@ -316,6 +316,85 @@ class emptyStream implements Stream {
   }
 }
 
+class memoryStream implements Stream {
+  private sent: Message | null = null
+  private sentQueue: (Message | null)[] = []
+  private waiters: ((msg: Message | null) => void)[] = []
+  private closed = false
+  private recvConsumed = false
+
+  constructor(
+    private ctx: context.Context,
+    private recv: Message | null,
+  ) {}
+
+  public Context(): context.Context {
+    return this.ctx
+  }
+
+  public MsgSend(msg: Message | null): $.GoError {
+    this.sent = msg
+    const waiter = this.waiters.shift()
+    if (waiter != null) {
+      waiter(msg)
+      return null
+    }
+    this.sentQueue.push(msg)
+    return null
+  }
+
+  public MsgRecv(msg: Message | null): MaybePromise<$.GoError> {
+    if (!this.recvConsumed) {
+      this.recvConsumed = true
+      if (msg != null && this.recv != null) {
+        Object.assign(msg, this.recv)
+      }
+      return null
+    }
+    const next = this.sentQueue.shift()
+    if (next !== undefined) {
+      if (msg != null && next != null) {
+        Object.assign(msg, next)
+      }
+      return null
+    }
+    if (this.closed) {
+      return io.EOF
+    }
+    return new Promise<$.GoError>((resolve) => {
+      this.waiters.push((sent) => {
+        if (msg != null && sent != null) {
+          Object.assign(msg, sent)
+        }
+        resolve(null)
+      })
+    })
+  }
+
+  public CloseSend(): $.GoError {
+    return null
+  }
+
+  public Close(): $.GoError {
+    this.closed = true
+    for (const waiter of this.waiters.splice(0)) {
+      waiter(null)
+    }
+    return null
+  }
+
+  public CopySentTo(output: Message | null): void {
+    if (output != null && this.sent != null) {
+      Object.assign(output, this.sent)
+      return
+    }
+    const next = this.sentQueue.shift()
+    if (output != null && next != null) {
+      Object.assign(output, next)
+    }
+  }
+}
+
 class streamWithClose implements Stream {
   constructor(
     private stream: Stream,
@@ -592,15 +671,418 @@ export class Server {
     _ctx: context.Context,
     _rwc: io.ReadWriteCloser | null,
   ): void {}
+
+  public AcceptMuxedConn(
+    _ctx: context.Context,
+    _conn: MuxedConn | null,
+  ): $.GoError {
+    return null
+  }
 }
 
 export function NewServer(invoker: Invoker | null): Server {
   return new Server({ invoker })
 }
 
-export type PacketHandler = (pkt: Packet | null) => $.GoError
-export type PacketDataHandler = (data: $.Slice<number>) => $.GoError
-export type CloseHandler = (closeErr: $.GoError) => void
+export interface PacketWriter {
+  WritePacket(packet: Packet | null): MaybePromise<$.GoError>
+  Close(): MaybePromise<$.GoError>
+}
+
+export type OpenStreamFunc = ((
+  ctx: context.Context,
+  msgHandler: PacketDataHandler,
+  closeHandler: CloseHandler,
+) => MaybePromise<[PacketWriter | null, $.GoError]>) & {
+  __server?: Server
+}
+
+class transportClient implements Client {
+  constructor(private openStream: OpenStreamFunc | null) {}
+
+  public async ExecCall(
+    ctx: context.Context,
+    service: string,
+    method: string,
+    input: Message | null,
+    output: Message | null,
+  ): Promise<$.GoError> {
+    if (this.openStream == null) {
+      return ErrNoAvailableClients
+    }
+    const writerResult = await this.openStream(
+      ctx,
+      () => null,
+      () => undefined,
+    )
+    if (writerResult == null) {
+      return ErrNoAvailableClients
+    }
+    const writer = writerResult[0]
+    const err = writerResult[1]
+    if (err != null) {
+      return err
+    }
+    if (input != null) {
+      const [data, marshalErr] = input.MarshalVT()
+      if (marshalErr != null) {
+        return marshalErr
+      }
+      const writeErr = await writer?.WritePacket(
+        NewCallStartPacket(service, method, data, $.len(data) === 0),
+      )
+      if (writeErr != null) {
+        return writeErr
+      }
+    }
+    if (output != null) {
+      output.Reset()
+    }
+    return await writer?.Close() ?? null
+  }
+
+  public async NewStream(
+    ctx: context.Context,
+    service: string,
+    method: string,
+    firstMsg: Message | null,
+  ): Promise<[Stream | null, $.GoError]> {
+    if (this.openStream == null) {
+      return [null, ErrNoAvailableClients]
+    }
+    const writerResult = await this.openStream(
+      ctx,
+      () => null,
+      () => undefined,
+    )
+    if (writerResult == null) {
+      return [null, ErrNoAvailableClients]
+    }
+    const writer = writerResult[0]
+    const err = writerResult[1]
+    if (err != null) {
+      return [null, err]
+    }
+    if (firstMsg != null) {
+      const [data, marshalErr] = firstMsg.MarshalVT()
+      if (marshalErr != null) {
+        return [null, marshalErr]
+      }
+      const writeErr = await writer?.WritePacket(
+        NewCallStartPacket(service, method, data, $.len(data) === 0),
+      )
+      if (writeErr != null) {
+        return [null, writeErr]
+      }
+    }
+    return [
+      NewStreamWithClose(new emptyStream(ctx), () => writer?.Close() ?? null),
+      null,
+    ]
+  }
+}
+
+export function NewClient(openStream: OpenStreamFunc | null): Client {
+  if (openStream?.__server != null) {
+    return NewClientWithInvoker(openStream.__server.GetInvoker())
+  }
+  return new transportClient(openStream)
+}
+
+class invokerClient implements Client {
+  constructor(
+    private invoker: Invoker | null,
+    private contextFn: ((ctx: context.Context) => context.Context) | null = null,
+  ) {}
+
+  public async ExecCall(
+    ctx: context.Context,
+    service: string,
+    method: string,
+    input: Message | null,
+    output: Message | null,
+  ): Promise<$.GoError> {
+    if (this.invoker == null) {
+      return ErrNoAvailableClients
+    }
+    const stream = new memoryStream(
+      this.contextFn == null ? ctx : this.contextFn(ctx),
+      input,
+    )
+    const [handled, err] = await this.invoker.InvokeMethod(
+      service,
+      method,
+      stream,
+    )
+    if (err != null) {
+      return err
+    }
+    if (!handled) {
+      return ErrUnimplemented
+    }
+    stream.CopySentTo(output)
+    return null
+  }
+
+  public async NewStream(
+    ctx: context.Context,
+    service: string,
+    method: string,
+    firstMsg: Message | null,
+  ): Promise<[Stream | null, $.GoError]> {
+    if (this.invoker == null) {
+      return [null, ErrNoAvailableClients]
+    }
+    const stream = new memoryStream(
+      this.contextFn == null ? ctx : this.contextFn(ctx),
+      firstMsg,
+    )
+    const pending = Promise.resolve(
+      this.invoker.InvokeMethod(service, method, stream),
+    )
+    pending.then(([handled, err]) => {
+      if (!handled || err != null) {
+        stream.Close()
+      }
+    })
+    return [stream, null]
+  }
+}
+
+export function NewClientWithInvoker(
+  invoker: Invoker | null,
+  contextFn: ((ctx: context.Context) => context.Context) | null = null,
+): Client {
+  return new invokerClient(invoker, contextFn)
+}
+
+export type PacketHandler =
+  | ((pkt: Packet | null) => MaybePromise<$.GoError>)
+  | null
+export type PacketDataHandler =
+  | ((data: $.Slice<number>) => MaybePromise<$.GoError>)
+  | null
+export type CloseHandler = ((closeErr: $.GoError) => void) | null
+
+class streamWithContext implements Stream {
+  constructor(
+    private stream: Stream,
+    private ctx: context.Context,
+  ) {}
+
+  public Context(): context.Context {
+    return this.ctx
+  }
+
+  public MsgSend(msg: Message | null): MaybePromise<$.GoError> {
+    return this.stream.MsgSend(msg)
+  }
+
+  public MsgRecv(msg: Message | null): MaybePromise<$.GoError> {
+    return this.stream.MsgRecv(msg)
+  }
+
+  public CloseSend(): MaybePromise<$.GoError> {
+    return this.stream.CloseSend()
+  }
+
+  public Close(): MaybePromise<$.GoError> {
+    return this.stream.Close()
+  }
+}
+
+export function NewStreamWithContext(
+  stream: Stream | null,
+  ctx: context.Context,
+): Stream {
+  return new streamWithContext(stream ?? new emptyStream(ctx), ctx)
+}
+
+export class ServerRPC {
+  constructor(
+    private ctx: context.Context,
+    private invoker: Invoker | null,
+    private writer: PacketWriter | null,
+  ) {}
+
+  public async HandlePacketData(data: $.Slice<number>): Promise<$.GoError> {
+    const pkt = new Packet()
+    const err = pkt.UnmarshalVT(data)
+    if (err != null) {
+      return err
+    }
+    return this.HandlePacket(pkt)
+  }
+
+  public async HandlePacket(pkt: Packet | null): Promise<$.GoError> {
+    if (pkt == null) {
+      return null
+    }
+    const body = pkt.GetBody()
+    if (body instanceof Packet_CallStart) {
+      return this.HandleCallStart(body.CallStart)
+    }
+    return null
+  }
+
+  public async HandleCallStart(pkt: CallStart | null): Promise<$.GoError> {
+    if (pkt == null || this.invoker == null) {
+      return ErrUnimplemented
+    }
+    const stream = new emptyStream(this.ctx)
+    const [handled, err] = await this.invoker.InvokeMethod(
+      pkt.GetRpcService(),
+      pkt.GetRpcMethod(),
+      stream,
+    )
+    const callErr = err ?? (handled ? null : ErrUnimplemented)
+    await this.writer?.WritePacket(NewCallDataPacket(null, false, true, callErr))
+    return callErr
+  }
+
+  public HandleStreamClose(_closeErr: $.GoError): void {}
+
+  public Wait(_ctx: context.Context): $.GoError {
+    return null
+  }
+}
+
+export function NewServerRPC(
+  ctx: context.Context,
+  invoker: Invoker | null,
+  writer: PacketWriter | null,
+): ServerRPC {
+  return new ServerRPC(ctx, invoker, writer)
+}
+
+export class PacketReadWriter implements PacketWriter {
+  constructor(private rw: io.ReadWriteCloser | null) {}
+
+  public Write(data: $.Slice<number>): [number, $.GoError] {
+    if (this.rw == null) {
+      return [0, ErrNilWriter]
+    }
+    return this.rw.Write(data)
+  }
+
+  public WritePacket(_packet: Packet | null): $.GoError {
+    return this.rw == null ? ErrNilWriter : null
+  }
+
+  public ReadPump(_cb: PacketDataHandler, closed: CloseHandler): void {
+    if (closed != null) {
+      closed(null)
+    }
+  }
+
+  public ReadToHandler(_cb: PacketDataHandler): $.GoError {
+    return null
+  }
+
+  public Close(): $.GoError {
+    return this.rw?.Close() ?? null
+  }
+}
+
+export function NewPacketReadWriter(
+  rw: io.ReadWriteCloser | null,
+): PacketReadWriter {
+  return new PacketReadWriter(rw)
+}
+
+export function NewServerPipe(server: Server | null): OpenStreamFunc {
+  const openStream = ((
+    _ctx: context.Context,
+    _msgHandler: PacketDataHandler,
+    _closeHandler: CloseHandler,
+  ): [PacketWriter | null, $.GoError] => [new closedPacketWriter(), null]) as
+    OpenStreamFunc
+  if (server != null) {
+    openStream.__server = server
+  }
+  return openStream
+}
+
+export class MuxedConn {
+  constructor(
+    public rwc: any = null,
+    public outbound = false,
+  ) {}
+
+  public Close(): $.GoError {
+    return this.rwc?.Close() ?? null
+  }
+}
+
+class closedPacketWriter implements PacketWriter {
+  public WritePacket(_packet: Packet | null): $.GoError {
+    return ErrUnimplemented
+  }
+
+  public Close(): $.GoError {
+    return null
+  }
+}
+
+export function NewOpenStreamWithMuxedConn(_conn: MuxedConn): OpenStreamFunc {
+  return () => [new closedPacketWriter(), null]
+}
+
+export function NewMuxedConn(
+  rwc: any,
+  outbound: boolean,
+  _yamuxConf: unknown,
+): [MuxedConn | null, $.GoError] {
+  return [new MuxedConn(rwc, outbound), null]
+}
+
+export function NewWebSocketConn(
+  _ctx: context.Context,
+  conn: unknown,
+  isServer: boolean,
+  yamuxConf: unknown,
+): [MuxedConn | null, $.GoError] {
+  return NewMuxedConn(conn, !isServer, yamuxConf)
+}
+
+export function NewClientWithMuxedConn(_conn: MuxedConn | null): Client {
+  return NewClientWithInvoker(null)
+}
+
+export function NewMuxedConnWithRwc(
+  _ctx: context.Context,
+  _rwc: io.ReadWriteCloser | null,
+  _outbound: boolean,
+  _yamuxConf: unknown,
+): [MuxedConn | null, $.GoError] {
+  return [new MuxedConn(_rwc, _outbound), null]
+}
+
+class clientInvoker implements Invoker {
+  constructor(private client: Client | null) {}
+
+  public async InvokeMethod(
+    serviceID: string,
+    methodID: string,
+    stream: Stream | null,
+  ): Promise<[boolean, $.GoError]> {
+    if (this.client == null || stream == null) {
+      return [false, null]
+    }
+    const [remote, err] = await this.client.NewStream(
+      stream.Context(),
+      serviceID,
+      methodID,
+      null,
+    )
+    await remote?.Close()
+    return [true, err]
+  }
+}
+
+export function NewClientInvoker(client: Client | null): Invoker {
+  return new clientInvoker(client)
+}
 
 export class Packet {
   public Body: unknown = null
@@ -635,6 +1117,22 @@ export class CallStart {
   public RpcMethod = ''
   public Data: $.Slice<number> = null
   public DataIsZero = false
+
+  public GetRpcService(): string {
+    return this.RpcService
+  }
+
+  public GetRpcMethod(): string {
+    return this.RpcMethod
+  }
+
+  public GetData(): $.Slice<number> {
+    return this.Data
+  }
+
+  public GetDataIsZero(): boolean {
+    return this.DataIsZero
+  }
 }
 
 export class CallData {
@@ -642,6 +1140,22 @@ export class CallData {
   public DataIsZero = false
   public Complete = false
   public Error = ''
+
+  public GetData(): $.Slice<number> {
+    return this.Data
+  }
+
+  public GetDataIsZero(): boolean {
+    return this.DataIsZero
+  }
+
+  public GetComplete(): boolean {
+    return this.Complete
+  }
+
+  public GetError(): string {
+    return this.Error
+  }
 }
 
 export class Packet_CallStart {
@@ -665,7 +1179,7 @@ export function NewPacketDataHandler(
     if (err != null) {
       return err
     }
-    return handler(pkt)
+    return handler?.(pkt) ?? null
   }
 }
 

package/gs/github.com/aperturerobotics/starpc/srpc/meta.json

@@ -10,6 +10,8 @@
     "Client.NewStream": true,
     "ClientSet.ExecCall": true,
     "ClientSet.NewStream": true,
+    "PacketWriter.WritePacket": true,
+    "PacketWriter.Close": true,
     "PrefixClient.ExecCall": true,
     "PrefixClient.NewStream": true,
     "Stream.MsgSend": true,
@@ -30,6 +32,10 @@
     "StreamSendAndClose.Close": true,
     "StreamSendAndClose.Send": true,
     "StreamSendAndClose.SendAndClose": true,
+    "ServerRPC.HandlePacketData": true,
+    "ServerRPC.HandlePacket": true,
+    "ServerRPC.HandleCallStart": true,
+    "clientInvoker.InvokeMethod": true,
     "InvokerFunc.InvokeMethod": true,
     "InvokerSlice.InvokeMethod": true,
     "Invoker.InvokeMethod": true,

package/gs/github.com/aperturerobotics/util/conc/index.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+import { makeChannel } from '../../../../builtin/index.js'
+import { Background } from '../../../../context/index.js'
+import { NewConcurrentQueue } from './index.js'
+
+const tick = () => new Promise<void>((resolve) => queueMicrotask(resolve))
+
+describe('util/conc override', () => {
+  test('runs queued jobs within the concurrency limit', async () => {
+    const release = makeChannel<{}>(0, {}, 'both')
+    const started: number[] = []
+    const done: number[] = []
+    const job = (idx: number) => async () => {
+      started.push(idx)
+      await release.receive()
+      done.push(idx)
+    }
+
+    const q = NewConcurrentQueue(2, job(0), job(1))
+    const [queued, running] = q.Enqueue([job(2), job(3), job(4)])
+    expect([queued, running]).toEqual([3, 2])
+
+    await tick()
+    expect(started).toEqual([0, 1])
+
+    release.close()
+    expect(await q.WaitIdle(Background(), null)).toBeNull()
+    expect(done).toEqual([0, 1, 2, 3, 4])
+  })
+})