starpc 0.49.18 → 0.49.20

package/dist/srpc/rpcproto.pb.js

@@ -1,10 +1,11 @@
 // @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
-import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';
+import { createMessageType } from '@aptre/protobuf-es-lite/message';
+import { ScalarType } from '@aptre/protobuf-es-lite/scalar';
 export const protobufPackage = 'srpc';
-// CallStart contains the message type declaration for CallStart.
-export const CallStart = createMessageType({
+export const CallStart = 
+/* @__PURE__ */ createMessageType({
     typeName: 'srpc.CallStart',
     fields: [
         { no: 1, name: 'rpc_service', kind: 'scalar', T: ScalarType.STRING },
@@ -14,8 +15,8 @@ export const CallStart = createMessageType({
     ],
     packedByDefault: true,
 });
-// CallData contains the message type declaration for CallData.
-export const CallData = createMessageType({
+export const CallData = 
+/* @__PURE__ */ createMessageType({
     typeName: 'srpc.CallData',
     fields: [
         { no: 1, name: 'data', kind: 'scalar', T: ScalarType.BYTES },
@@ -25,8 +26,7 @@ export const CallData = createMessageType({
     ],
     packedByDefault: true,
 });
-// Packet contains the message type declaration for Packet.
-export const Packet = createMessageType({
+export const Packet = /* @__PURE__ */ createMessageType({
     typeName: 'srpc.Packet',
     fields: [
         {

package/dist/srpc/server-invocation.d.ts

@@ -0,0 +1,17 @@
+export type TerminalKind = 'committed' | 'canceled' | 'transportLost' | 'closed' | 'abandoned';
+export declare class ServerInvocation implements AbortSignal {
+    readonly signal: AbortSignal;
+    private readonly waitFn;
+    constructor(signal: AbortSignal, waitFn: (ownerSignal: AbortSignal) => Promise<TerminalKind>);
+    get aborted(): boolean;
+    get onabort(): typeof this.signal.onabort;
+    set onabort(value: typeof this.signal.onabort);
+    get reason(): any;
+    throwIfAborted(): void;
+    addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    waitTerminal(ownerSignal: AbortSignal): Promise<TerminalKind>;
+}

package/dist/srpc/server-invocation.js

@@ -0,0 +1,37 @@
+// ServerInvocation exposes the invocation signal and terminal wait.
+export class ServerInvocation {
+    signal;
+    waitFn;
+    constructor(signal, waitFn) {
+        this.signal = signal;
+        this.waitFn = waitFn;
+    }
+    get aborted() {
+        return this.signal.aborted;
+    }
+    get onabort() {
+        return this.signal.onabort;
+    }
+    set onabort(value) {
+        this.signal.onabort = value;
+    }
+    get reason() {
+        return this.signal.reason;
+    }
+    throwIfAborted() {
+        this.signal.throwIfAborted();
+    }
+    addEventListener(type, listener, options) {
+        this.signal.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, options) {
+        this.signal.removeEventListener(type, listener, options);
+    }
+    dispatchEvent(event) {
+        return this.signal.dispatchEvent(event);
+    }
+    // waitTerminal waits for a remote terminal or owner-signal cancellation.
+    waitTerminal(ownerSignal) {
+        return this.waitFn(ownerSignal);
+    }
+}

package/dist/srpc/server-rpc.js

@@ -1,4 +1,5 @@
 import { CommonRPC } from './common-rpc.js';
+import { ServerInvocation } from './server-invocation.js';
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
     // lookupMethod looks up the incoming RPC methods.
@@ -37,8 +38,9 @@ export class ServerRPC extends CommonRPC {
     // invokeRPC starts invoking the RPC handler.
     async invokeRPC(invokeFn) {
         const dataSink = this._createDataSink();
+        const invocation = new ServerInvocation(this.invocationSignal, (ownerSignal) => this.waitTerminal(ownerSignal));
         try {
-            await invokeFn(this.rpcDataSource, dataSink);
+            await invokeFn(this.rpcDataSource, dataSink, invocation);
         }
         catch (err) {
             this.close(err);

package/echo/echo.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.12.1
+// protoc-gen-go-lite version: v0.13.0
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/echo/echo.pb.ts

@@ -2,8 +2,10 @@
 // @generated from file github.com/aperturerobotics/starpc/echo/echo.proto (package echo, syntax proto3)
 /* eslint-disable */
 
-import type { MessageType, PartialFieldInfo } from '@aptre/protobuf-es-lite'
-import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite'
+import type { MessageType } from '@aptre/protobuf-es-lite/message'
+import { createMessageType } from '@aptre/protobuf-es-lite/message'
+import { ScalarType } from '@aptre/protobuf-es-lite/scalar'
+import type { PartialFieldInfo } from '@aptre/protobuf-es-lite/field'
 
 export const protobufPackage = 'echo'
 
@@ -19,11 +21,10 @@ export interface EchoMsg {
   body?: string
 }
 
-// EchoMsg contains the message type declaration for EchoMsg.
-export const EchoMsg: MessageType<EchoMsg> = createMessageType({
+export const EchoMsg: MessageType<EchoMsg> = /* @__PURE__ */ createMessageType({
   typeName: 'echo.EchoMsg',
   fields: [
     { no: 1, name: 'body', kind: 'scalar', T: ScalarType.STRING },
-  ] as readonly PartialFieldInfo[],
+  ] satisfies readonly PartialFieldInfo[],
   packedByDefault: true,
 })

package/echo/echo_srpc.pb.cpp

@@ -1,7 +1,7 @@
 //go:build deps_only
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.46.1
+// protoc-gen-starpc-cpp version: v0.49.7
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #include "echo_srpc.pb.hpp"

package/echo/echo_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.46.1
+// protoc-gen-srpc version: v0.49.7
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 package echo

package/echo/echo_srpc.pb.hpp

@@ -1,7 +1,7 @@
 //go:build deps_only && cgo
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.46.1
+// protoc-gen-starpc-cpp version: v0.49.7
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #pragma once

package/echo/echo_srpc.pb.rs

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-starpc-rust. DO NOT EDIT.
-// protoc-gen-starpc-rust version: v0.46.1
+// protoc-gen-starpc-rust version: v0.49.7
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #[allow(unused_imports)]

package/integration/cross-language/go-client/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net"
@@ -14,14 +15,32 @@ import (
 const bodyTxt = "hello world via starpc cross-language e2e test"
 
 func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "usage: go-client <addr>\n")
+	receiptMode := len(os.Args) > 1 && os.Args[1] == "receipt"
+	receiptCase := ""
+	addrIndex := 1
+	if receiptMode {
+		if len(os.Args) < 3 {
+			fmt.Fprintf(os.Stderr, "usage: go-client receipt <case> <addr>\n")
+			os.Exit(1)
+		}
+		receiptCase = os.Args[2]
+		addrIndex = 3
+		switch receiptCase {
+		case "commit", "abort", "loss", "bare-close":
+		default:
+			fmt.Fprintf(os.Stderr, "unknown receipt case: %s\n", receiptCase)
+			os.Exit(1)
+		}
+	}
+	if len(os.Args) <= addrIndex {
+		fmt.Fprintf(os.Stderr, "usage: go-client [receipt <case>] <addr>\n")
 		os.Exit(1)
 	}
-	addr := os.Args[1]
-
+	addr := os.Args[addrIndex]
+	var conn net.Conn
 	openStream := func(ctx context.Context, msgHandler srpc.PacketDataHandler, closeHandler srpc.CloseHandler) (srpc.PacketWriter, error) {
-		conn, err := net.Dial("tcp", addr) //nolint:gosec
+		var err error
+		conn, err = net.Dial("tcp", addr) //nolint:gosec
 		if err != nil {
 			return nil, err
 		}
@@ -33,6 +52,14 @@ func main() {
 	client := srpc.NewClient(openStream)
 	echoClient := echo.NewSRPCEchoerClient(client)
 	ctx := context.Background()
+	if receiptMode {
+		if err := testReceipt(ctx, client, &conn, receiptCase); err != nil {
+			fmt.Fprintf(os.Stderr, "receipt test failed: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Println("All tests passed.")
+		return
+	}
 
 	if err := testUnary(ctx, echoClient); err != nil {
 		fmt.Fprintf(os.Stderr, "unary test failed: %v\n", err)
@@ -70,6 +97,79 @@ func testUnary(ctx context.Context, client echo.SRPCEchoerClient) error {
 	return nil
 }
 
+func testReceipt(
+	ctx context.Context,
+	client srpc.Client,
+	conn *net.Conn,
+	receiptCase string,
+) error {
+	fmt.Printf("Testing held unary receipt (%s)...\n", receiptCase)
+	out := new(echo.EchoMsg)
+	receipt, err := srpc.ExecCallReceipt(
+		ctx, client, echo.SRPCEchoerServiceID, "Echo",
+		&echo.EchoMsg{Body: bodyTxt}, out,
+	)
+	if err != nil {
+		return fmt.Errorf("receipt call: %w", err)
+	}
+	if out.GetBody() != bodyTxt {
+		return fmt.Errorf("expected %q got %q", bodyTxt, out.GetBody())
+	}
+
+	switch receiptCase {
+	case "commit":
+		if err := receipt.Commit(); err != nil {
+			return fmt.Errorf("receipt commit: %w", err)
+		}
+	case "abort":
+		if err := receipt.Abort(); err != nil {
+			return fmt.Errorf("receipt abort: %w", err)
+		}
+	case "loss":
+		if *conn == nil {
+			return errors.New("receipt connection is nil")
+		}
+		tcpConn, ok := (*conn).(*net.TCPConn)
+		if !ok {
+			return errors.New("receipt connection is not TCP")
+		}
+		if err := tcpConn.SetLinger(0); err != nil {
+			return fmt.Errorf("set receipt loss linger: %w", err)
+		}
+		if err := tcpConn.Close(); err != nil {
+			return fmt.Errorf("close lost connection: %w", err)
+		}
+		if err := receipt.Commit(); err == nil {
+			return errors.New("loss receipt commit unexpectedly succeeded")
+		}
+	case "bare-close":
+		if *conn == nil {
+			return errors.New("receipt connection is nil")
+		}
+		tcpConn, ok := (*conn).(*net.TCPConn)
+		if !ok {
+			return errors.New("receipt connection is not TCP")
+		}
+		if err := tcpConn.CloseWrite(); err != nil {
+			return fmt.Errorf("close receipt write side: %w", err)
+		}
+		if err := receipt.Commit(); err == nil {
+			return errors.New("bare-close receipt commit unexpectedly succeeded")
+		}
+	default:
+		return fmt.Errorf("unknown receipt case: %s", receiptCase)
+	}
+
+	if err := emitReceiptEvent(
+		fmt.Sprintf("CLIENT_RECEIPT_RESOLVED %s", receiptTerminalName(receiptCase)),
+	); err != nil {
+		return fmt.Errorf("record receipt resolution: %w", err)
+	}
+
+	fmt.Println("  PASSED")
+	return nil
+}
+
 func testServerStream(ctx context.Context, client echo.SRPCEchoerClient) error {
 	fmt.Println("Testing ServerStream RPC...")
 	strm, err := client.EchoServerStream(ctx, &echo.EchoMsg{Body: bodyTxt})
@@ -149,3 +249,35 @@ func testBidiStream(ctx context.Context, client echo.SRPCEchoerClient) error {
 	fmt.Println("  PASSED")
 	return nil
 }
+
+func receiptTerminalName(receiptCase string) string {
+	switch receiptCase {
+	case "commit":
+		return "committed"
+	case "abort":
+		return "canceled"
+	case "loss":
+		return "transportLost"
+	case "bare-close":
+		return "closed"
+	default:
+		return "unknown"
+	}
+}
+
+func emitReceiptEvent(line string) error {
+	fmt.Println(line)
+	fifo := os.Getenv("RECEIPT_EVENT_FIFO")
+	if fifo == "" {
+		return nil
+	}
+	file, err := os.OpenFile(fifo, os.O_WRONLY, 0) //nolint:gosec // FIFO path is created by the local integration runner.
+	if err != nil {
+		return err
+	}
+	if _, err := file.WriteString(line + "\n"); err != nil {
+		_ = file.Close()
+		return err
+	}
+	return file.Close()
+}

package/integration/cross-language/go-server/main.go

@@ -6,6 +6,7 @@ import (
 	"net"
 	"os"
 	"os/signal"
+	"sync"
 
 	"github.com/aperturerobotics/starpc/echo"
 	"github.com/aperturerobotics/starpc/srpc"
@@ -15,14 +16,73 @@ func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
 	defer cancel()
 
+	receiptMode := len(os.Args) > 1 && os.Args[1] == "receipt"
+	receiptCase := ""
+	if receiptMode {
+		if len(os.Args) < 3 {
+			fmt.Fprintln(os.Stderr, "usage: go-server receipt <case>")
+			os.Exit(1)
+		}
+		receiptCase = os.Args[2]
+		switch receiptCase {
+		case "commit", "abort", "loss", "bare-close":
+		default:
+			fmt.Fprintf(os.Stderr, "unknown receipt case: %s\n", receiptCase)
+			os.Exit(1)
+		}
+	}
 	mux := srpc.NewMux()
 	echoServer := echo.NewEchoServer(mux)
 	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
 		fmt.Fprintf(os.Stderr, "register error: %v\n", err)
 		os.Exit(1)
 	}
-	server := srpc.NewServer(mux)
-
+	var receiptDone <-chan struct{}
+	var finishReceipt func()
+	if receiptMode {
+		done := make(chan struct{})
+		var doneOnce sync.Once
+		receiptDone = done
+		finishReceipt = func() {
+			doneOnce.Do(func() {
+				close(done)
+			})
+		}
+	}
+	var invoker srpc.Invoker = mux
+	if receiptMode {
+		invoker = srpc.InvokerFunc(func(
+			serviceID, methodID string,
+			strm srpc.Stream,
+		) (bool, error) {
+			handled, err := mux.InvokeMethod(serviceID, methodID, strm)
+			if err != nil || !handled {
+				return handled, err
+			}
+			invocation, ok := srpc.GetServerInvocation(strm.Context())
+			if !ok {
+				return true, context.Canceled
+			}
+			kind, waitErr := invocation.WaitTerminal(context.Background())
+			markerErr := emitReceiptEvent(
+				fmt.Sprintf("SERVER_RECEIPT_TERMINAL %s", terminalName(kind)),
+			)
+			if waitErr != nil {
+				return true, waitErr
+			}
+			if markerErr != nil {
+				return true, markerErr
+			}
+			if kind != srpc.TerminalCommitted {
+				finishReceipt()
+			}
+			return true, nil
+		})
+	}
+	var server *srpc.Server
+	if !receiptMode {
+		server = srpc.NewServer(invoker)
+	}
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "listen error: %v\n", err)
@@ -30,6 +90,13 @@ func main() {
 	}
 	defer ln.Close()
 
+	if receiptMode {
+		go func() {
+			<-receiptDone
+			_ = ln.Close()
+		}()
+	}
+
 	fmt.Printf("LISTENING %s\n", ln.Addr().String())
 
 	go func() {
@@ -42,6 +109,82 @@ func main() {
 		if err != nil {
 			return
 		}
-		go server.HandleStream(ctx, conn)
+		if receiptMode {
+			go handleReceiptStream(ctx, conn, invoker, finishReceipt)
+		} else {
+			go server.HandleStream(ctx, conn)
+		}
+	}
+}
+
+func handleReceiptStream(
+	ctx context.Context,
+	conn net.Conn,
+	invoker srpc.Invoker,
+	finishReceipt func(),
+) {
+	prw := srpc.NewPacketReadWriter(conn)
+	writer := &receiptPacketWriter{
+		inner:         prw,
+		finishReceipt: finishReceipt,
+	}
+	rpc := srpc.NewServerRPC(ctx, invoker, writer)
+	prw.ReadPump(rpc.HandlePacketData, rpc.HandleStreamClose)
+}
+
+type receiptPacketWriter struct {
+	inner         srpc.PacketWriter
+	finishReceipt func()
+}
+
+func (w *receiptPacketWriter) WritePacket(pkt *srpc.Packet) error {
+	if err := w.inner.WritePacket(pkt); err != nil {
+		return err
+	}
+	data := pkt.GetCallData()
+	if data != nil && data.GetComplete() && data.GetError() == "" {
+		if err := emitReceiptEvent("SERVER_RECEIPT_ACK committed"); err != nil {
+			return err
+		}
+		w.finishReceipt()
+	}
+	return nil
+}
+
+func (w *receiptPacketWriter) Close() error {
+	return w.inner.Close()
+}
+
+func terminalName(kind srpc.TerminalKind) string {
+	switch kind {
+	case srpc.TerminalCommitted:
+		return "committed"
+	case srpc.TerminalCanceled:
+		return "canceled"
+	case srpc.TerminalLost:
+		return "transportLost"
+	case srpc.TerminalClosed:
+		return "closed"
+	case srpc.TerminalAbandoned:
+		return "abandoned"
+	default:
+		return "unknown"
+	}
+}
+
+func emitReceiptEvent(line string) error {
+	fmt.Println(line)
+	fifo := os.Getenv("RECEIPT_EVENT_FIFO")
+	if fifo == "" {
+		return nil
+	}
+	file, err := os.OpenFile(fifo, os.O_WRONLY, 0) //nolint:gosec // FIFO path is created by the local integration runner.
+	if err != nil {
+		return err
+	}
+	if _, err := file.WriteString(line + "\n"); err != nil {
+		_ = file.Close()
+		return err
 	}
+	return file.Close()
 }