starpc 0.13.2 → 0.14.0

package/dist/srpc/rpcproto.pb.d.ts

@@ -1,14 +1,17 @@
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
 export declare const protobufPackage = "srpc";
 /** Packet is a message sent over a srpc packet connection. */
 export interface Packet {
     body?: {
-        $case: "callStart";
+        $case: 'callStart';
         callStart: CallStart;
     } | {
-        $case: "callData";
+        $case: 'callData';
         callData: CallData;
+    } | {
+        $case: 'callCancel';
+        callCancel: boolean;
     };
 }
 /** CallStart requests starting a new RPC call. */
@@ -71,6 +74,10 @@ export declare const Packet: {
             } | undefined;
         } & {
             $case: "callData";
+        }) | ({
+            callCancel?: boolean | undefined;
+        } & {
+            $case: "callCancel";
         }) | undefined;
     } & {
         body?: ({
@@ -117,8 +124,15 @@ export declare const Packet: {
                 error?: string | undefined;
             } & { [K_2 in Exclude<keyof I["body"]["callData"], keyof CallData>]: never; }) | undefined;
             $case: "callData";
-        } & { [K_3 in Exclude<keyof I["body"], "callData" | "$case">]: never; }) | undefined;
-    } & { [K_4 in Exclude<keyof I, "body">]: never; }>(object: I): Packet;
+        } & { [K_3 in Exclude<keyof I["body"], "callData" | "$case">]: never; }) | ({
+            callCancel?: boolean | undefined;
+        } & {
+            $case: "callCancel";
+        } & {
+            callCancel?: boolean | undefined;
+            $case: "callCancel";
+        } & { [K_4 in Exclude<keyof I["body"], "callCancel" | "$case">]: never; }) | undefined;
+    } & { [K_5 in Exclude<keyof I, "body">]: never; }>(object: I): Packet;
 };
 export declare const CallStart: {
     encode(message: CallStart, writer?: _m0.Writer): _m0.Writer;
@@ -162,9 +176,9 @@ declare type Builtin = Date | Function | Uint8Array | string | number | boolean
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;
 } ? {
-    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
 } & {
-    $case: T["$case"];
+    $case: T['$case'];
 } : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;

package/dist/srpc/rpcproto.pb.js

@@ -1,18 +1,21 @@
 /* eslint-disable */
-import Long from "long";
-import _m0 from "protobufjs/minimal.js";
-export const protobufPackage = "srpc";
+import Long from 'long';
+import _m0 from 'protobufjs/minimal.js';
+export const protobufPackage = 'srpc';
 function createBasePacket() {
     return { body: undefined };
 }
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === "callStart") {
+        if (message.body?.$case === 'callStart') {
             CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
         }
-        if (message.body?.$case === "callData") {
+        if (message.body?.$case === 'callData') {
             CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
         }
+        if (message.body?.$case === 'callCancel') {
+            writer.uint32(24).bool(message.body.callCancel);
+        }
         return writer;
     },
     decode(input, length) {
@@ -23,10 +26,19 @@ export const Packet = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.body = { $case: "callStart", callStart: CallStart.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'callStart',
+                        callStart: CallStart.decode(reader, reader.uint32()),
+                    };
                     break;
                 case 2:
-                    message.body = { $case: "callData", callData: CallData.decode(reader, reader.uint32()) };
+                    message.body = {
+                        $case: 'callData',
+                        callData: CallData.decode(reader, reader.uint32()),
+                    };
+                    break;
+                case 3:
+                    message.body = { $case: 'callCancel', callCancel: reader.bool() };
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -66,40 +78,71 @@ export const Packet = {
     fromJSON(object) {
         return {
             body: isSet(object.callStart)
-                ? { $case: "callStart", callStart: CallStart.fromJSON(object.callStart) }
+                ? {
+                    $case: 'callStart',
+                    callStart: CallStart.fromJSON(object.callStart),
+                }
                 : isSet(object.callData)
-                    ? { $case: "callData", callData: CallData.fromJSON(object.callData) }
-                    : undefined,
+                    ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
+                    : isSet(object.callCancel)
+                        ? { $case: 'callCancel', callCancel: Boolean(object.callCancel) }
+                        : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
-        message.body?.$case === "callStart" &&
-            (obj.callStart = message.body?.callStart ? CallStart.toJSON(message.body?.callStart) : undefined);
-        message.body?.$case === "callData" &&
-            (obj.callData = message.body?.callData ? CallData.toJSON(message.body?.callData) : undefined);
+        message.body?.$case === 'callStart' &&
+            (obj.callStart = message.body?.callStart
+                ? CallStart.toJSON(message.body?.callStart)
+                : undefined);
+        message.body?.$case === 'callData' &&
+            (obj.callData = message.body?.callData
+                ? CallData.toJSON(message.body?.callData)
+                : undefined);
+        message.body?.$case === 'callCancel' &&
+            (obj.callCancel = message.body?.callCancel);
         return obj;
     },
     fromPartial(object) {
         const message = createBasePacket();
-        if (object.body?.$case === "callStart" && object.body?.callStart !== undefined && object.body?.callStart !== null) {
-            message.body = { $case: "callStart", callStart: CallStart.fromPartial(object.body.callStart) };
+        if (object.body?.$case === 'callStart' &&
+            object.body?.callStart !== undefined &&
+            object.body?.callStart !== null) {
+            message.body = {
+                $case: 'callStart',
+                callStart: CallStart.fromPartial(object.body.callStart),
+            };
+        }
+        if (object.body?.$case === 'callData' &&
+            object.body?.callData !== undefined &&
+            object.body?.callData !== null) {
+            message.body = {
+                $case: 'callData',
+                callData: CallData.fromPartial(object.body.callData),
+            };
         }
-        if (object.body?.$case === "callData" && object.body?.callData !== undefined && object.body?.callData !== null) {
-            message.body = { $case: "callData", callData: CallData.fromPartial(object.body.callData) };
+        if (object.body?.$case === 'callCancel' &&
+            object.body?.callCancel !== undefined &&
+            object.body?.callCancel !== null) {
+            message.body = { $case: 'callCancel', callCancel: object.body.callCancel };
         }
         return message;
     },
 };
 function createBaseCallStart() {
-    return { rpcService: "", rpcMethod: "", data: new Uint8Array(), dataIsZero: false };
+    return {
+        rpcService: '',
+        rpcMethod: '',
+        data: new Uint8Array(),
+        dataIsZero: false,
+    };
 }
 export const CallStart = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.rpcService !== "") {
+        if (message.rpcService !== '') {
             writer.uint32(10).string(message.rpcService);
         }
-        if (message.rpcMethod !== "") {
+        if (message.rpcMethod !== '') {
             writer.uint32(18).string(message.rpcMethod);
         }
         if (message.data.length !== 0) {
@@ -166,9 +209,11 @@ export const CallStart = {
     },
     fromJSON(object) {
         return {
-            rpcService: isSet(object.rpcService) ? String(object.rpcService) : "",
-            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : "",
-            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+            rpcService: isSet(object.rpcService) ? String(object.rpcService) : '',
+            rpcMethod: isSet(object.rpcMethod) ? String(object.rpcMethod) : '',
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
         };
     },
@@ -183,15 +228,20 @@ export const CallStart = {
     },
     fromPartial(object) {
         const message = createBaseCallStart();
-        message.rpcService = object.rpcService ?? "";
-        message.rpcMethod = object.rpcMethod ?? "";
+        message.rpcService = object.rpcService ?? '';
+        message.rpcMethod = object.rpcMethod ?? '';
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         return message;
     },
 };
 function createBaseCallData() {
-    return { data: new Uint8Array(), dataIsZero: false, complete: false, error: "" };
+    return {
+        data: new Uint8Array(),
+        dataIsZero: false,
+        complete: false,
+        error: '',
+    };
 }
 export const CallData = {
     encode(message, writer = _m0.Writer.create()) {
@@ -204,7 +254,7 @@ export const CallData = {
         if (message.complete === true) {
             writer.uint32(24).bool(message.complete);
         }
-        if (message.error !== "") {
+        if (message.error !== '') {
             writer.uint32(34).string(message.error);
         }
         return writer;
@@ -265,10 +315,12 @@ export const CallData = {
     },
     fromJSON(object) {
         return {
-            data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
             dataIsZero: isSet(object.dataIsZero) ? Boolean(object.dataIsZero) : false,
             complete: isSet(object.complete) ? Boolean(object.complete) : false,
-            error: isSet(object.error) ? String(object.error) : "",
+            error: isSet(object.error) ? String(object.error) : '',
         };
     },
     toJSON(message) {
@@ -285,28 +337,28 @@ export const CallData = {
         message.data = object.data ?? new Uint8Array();
         message.dataIsZero = object.dataIsZero ?? false;
         message.complete = object.complete ?? false;
-        message.error = object.error ?? "";
+        message.error = object.error ?? '';
         return message;
     },
 };
 var globalThis = (() => {
-    if (typeof globalThis !== "undefined") {
+    if (typeof globalThis !== 'undefined') {
         return globalThis;
     }
-    if (typeof self !== "undefined") {
+    if (typeof self !== 'undefined') {
         return self;
     }
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
         return window;
     }
-    if (typeof global !== "undefined") {
+    if (typeof global !== 'undefined') {
         return global;
     }
-    throw "Unable to locate global object";
+    throw 'Unable to locate global object';
 })();
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
     }
     else {
         const bin = globalThis.atob(b64);
@@ -319,14 +371,14 @@ function bytesFromBase64(b64) {
 }
 function base64FromBytes(arr) {
     if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString("base64");
+        return globalThis.Buffer.from(arr).toString('base64');
     }
     else {
         const bin = [];
         arr.forEach((byte) => {
             bin.push(String.fromCharCode(byte));
         });
-        return globalThis.btoa(bin.join(""));
+        return globalThis.btoa(bin.join(''));
     }
 }
 if (_m0.util.Long !== Long) {

package/e2e/e2e_test.go

@@ -5,28 +5,37 @@ import (
 	"io"
 	"net"
 	"testing"
+	"time"
 
+	e2e_mock "github.com/aperturerobotics/starpc/e2e/mock"
 	"github.com/aperturerobotics/starpc/echo"
 	"github.com/aperturerobotics/starpc/rpcstream"
 	"github.com/aperturerobotics/starpc/srpc"
 	"github.com/pkg/errors"
 )
 
+const bodyTxt = "hello world via starpc e2e test"
+
 // RunE2E runs an end to end test with a callback.
 func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
-	// construct the server
-	mux := srpc.NewMux()
-	echoServer := echo.NewEchoServer(mux)
-	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
-		t.Fatal(err.Error())
-	}
-	server := srpc.NewServer(mux)
+	RunE2E_Setup(t, func(server *srpc.Server, mux srpc.Mux, client srpc.Client) error {
+		// construct the server
+		echoServer := echo.NewEchoServer(mux)
+		if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
+			t.Fatal(err.Error())
+		}
 
+		// construct the client rpc interface
+		clientEcho := echo.NewSRPCEchoerClient(client)
+		return cb(clientEcho)
+	})
+}
+
+// RunE2E_Setup sets up the client and server and calls the callback.
+func RunE2E_Setup(t *testing.T, cb func(server *srpc.Server, mux srpc.Mux, client srpc.Client) error) {
 	// Alternatively:
 	// openStream := srpc.NewServerPipe(server)
 	// client := srpc.NewClient(openStream)
-
-	// construct the client
 	clientPipe, serverPipe := net.Pipe()
 
 	// outbound=true
@@ -36,6 +45,9 @@ func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 	}
 	client := srpc.NewClientWithMuxedConn(clientMp)
 
+	mux := srpc.NewMux()
+	server := srpc.NewServer(mux)
+
 	ctx := context.Background()
 	// outbound=false
 	serverMp, err := srpc.NewMuxedConn(serverPipe, false, nil)
@@ -46,11 +58,8 @@ func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 		_ = server.AcceptMuxedConn(ctx, serverMp)
 	}()
 
-	// construct the client rpc interface
-	clientEcho := echo.NewSRPCEchoerClient(client)
-
 	// call
-	if err := cb(clientEcho); err != nil {
+	if err := cb(server, mux, client); err != nil {
 		t.Fatal(err.Error())
 	}
 }
@@ -58,7 +67,6 @@ func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 func TestE2E_Unary(t *testing.T) {
 	ctx := context.Background()
 	RunE2E(t, func(client echo.SRPCEchoerClient) error {
-		bodyTxt := "hello world"
 		out, err := client.Echo(ctx, &echo.EchoMsg{
 			Body: bodyTxt,
 		})
@@ -102,7 +110,6 @@ func CheckServerStream(t *testing.T, out echo.SRPCEchoer_EchoServerStreamClient,
 func TestE2E_ServerStream(t *testing.T) {
 	ctx := context.Background()
 	RunE2E(t, func(client echo.SRPCEchoerClient) error {
-		bodyTxt := "hello world"
 		req := &echo.EchoMsg{
 			Body: bodyTxt,
 		}
@@ -114,6 +121,49 @@ func TestE2E_ServerStream(t *testing.T) {
 	})
 }
 
+func TestE2E_Cancel(t *testing.T) {
+	rctx := context.Background()
+	RunE2E_Setup(t, func(server *srpc.Server, mux srpc.Mux, client srpc.Client) error {
+		ctxCh := make(chan context.Context, 1)
+		doneCh := make(chan error, 1)
+		msrv := &e2e_mock.MockServer{
+			MockRequestCb: func(ctx context.Context, msg *e2e_mock.MockMsg) (*e2e_mock.MockMsg, error) {
+				ctxCh <- ctx
+				<-ctx.Done()
+				return nil, context.Canceled
+			},
+		}
+		_ = msrv.Register(mux)
+
+		ctx, ctxCancel := context.WithCancel(rctx)
+		mclient := e2e_mock.NewSRPCMockClient(client)
+		go func() {
+			_, err := mclient.MockRequest(ctx, &e2e_mock.MockMsg{Body: bodyTxt})
+			doneCh <- err
+		}()
+
+		var reqCtx context.Context
+		select {
+		case reqCtx = <-ctxCh:
+		case <-time.After(time.Millisecond * 100):
+			t.FailNow()
+		}
+
+		ctxCancel()
+		select {
+		case <-reqCtx.Done():
+		case <-time.After(time.Millisecond * 100):
+			t.Fatal("request ctx did not cancel after we canceled client-side ctx")
+		}
+		select {
+		case <-doneCh:
+		case <-time.After(time.Millisecond * 100):
+			t.Fatal("request did not exit on client side after we canceled ctx")
+		}
+		return nil
+	})
+}
+
 // CheckClientStream checks the server stream portion of the Echo test.
 func CheckClientStream(t *testing.T, out echo.SRPCEchoer_EchoClientStreamClient, req *echo.EchoMsg) error {
 	// send request

package/e2e/mock/mock.go

@@ -0,0 +1,29 @@
+package e2e_mock
+
+import (
+	context "context"
+
+	srpc "github.com/aperturerobotics/starpc/srpc"
+)
+
+// MockServer implements the server for Mock.
+type MockServer struct {
+	// MockRequestCb is the callback to implement MockRequest.
+	MockRequestCb func(ctx context.Context, msg *MockMsg) (*MockMsg, error)
+}
+
+// Register registers the Echo server with the Mux.
+func (e *MockServer) Register(mux srpc.Mux) error {
+	return SRPCRegisterMock(mux, e)
+}
+
+// MockRequest implements the mock request rpc.
+func (e *MockServer) MockRequest(ctx context.Context, msg *MockMsg) (*MockMsg, error) {
+	if e.MockRequestCb == nil {
+		return nil, srpc.ErrUnimplemented
+	}
+	return e.MockRequestCb(ctx, msg)
+}
+
+// _ is a type assertion
+var _ SRPCMockServer = ((*MockServer)(nil))

package/e2e/mock/mock.pb.go

@@ -0,0 +1,151 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.28.1-devel
+// 	protoc        v3.19.3
+// source: github.com/aperturerobotics/starpc/e2e/mock/mock.proto
+
+package e2e_mock
+
+import (
+	reflect "reflect"
+	sync "sync"
+
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// MockMsg is the mock message body.
+type MockMsg struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Body string `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (x *MockMsg) Reset() {
+	*x = MockMsg{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MockMsg) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MockMsg) ProtoMessage() {}
+
+func (x *MockMsg) ProtoReflect() protoreflect.Message {
+	mi := &file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MockMsg.ProtoReflect.Descriptor instead.
+func (*MockMsg) Descriptor() ([]byte, []int) {
+	return file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MockMsg) GetBody() string {
+	if x != nil {
+		return x.Body
+	}
+	return ""
+}
+
+var File_github_com_aperturerobotics_starpc_e2e_mock_mock_proto protoreflect.FileDescriptor
+
+var file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDesc = []byte{
+	0x0a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x65,
+	0x72, 0x74, 0x75, 0x72, 0x65, 0x72, 0x6f, 0x62, 0x6f, 0x74, 0x69, 0x63, 0x73, 0x2f, 0x73, 0x74,
+	0x61, 0x72, 0x70, 0x63, 0x2f, 0x65, 0x32, 0x65, 0x2f, 0x6d, 0x6f, 0x63, 0x6b, 0x2f, 0x6d, 0x6f,
+	0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x65, 0x32, 0x65, 0x2e, 0x6d, 0x6f,
+	0x63, 0x6b, 0x22, 0x1d, 0x0a, 0x07, 0x4d, 0x6f, 0x63, 0x6b, 0x4d, 0x73, 0x67, 0x12, 0x12, 0x0a,
+	0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64,
+	0x79, 0x32, 0x3b, 0x0a, 0x04, 0x4d, 0x6f, 0x63, 0x6b, 0x12, 0x33, 0x0a, 0x0b, 0x4d, 0x6f, 0x63,
+	0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x11, 0x2e, 0x65, 0x32, 0x65, 0x2e, 0x6d,
+	0x6f, 0x63, 0x6b, 0x2e, 0x4d, 0x6f, 0x63, 0x6b, 0x4d, 0x73, 0x67, 0x1a, 0x11, 0x2e, 0x65, 0x32,
+	0x65, 0x2e, 0x6d, 0x6f, 0x63, 0x6b, 0x2e, 0x4d, 0x6f, 0x63, 0x6b, 0x4d, 0x73, 0x67, 0x62, 0x06,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescOnce sync.Once
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescData = file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDesc
+)
+
+func file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescGZIP() []byte {
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescOnce.Do(func() {
+		file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescData = protoimpl.X.CompressGZIP(file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescData)
+	})
+	return file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDescData
+}
+
+var file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_goTypes = []interface{}{
+	(*MockMsg)(nil), // 0: e2e.mock.MockMsg
+}
+var file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_depIdxs = []int32{
+	0, // 0: e2e.mock.Mock.MockRequest:input_type -> e2e.mock.MockMsg
+	0, // 1: e2e.mock.Mock.MockRequest:output_type -> e2e.mock.MockMsg
+	1, // [1:2] is the sub-list for method output_type
+	0, // [0:1] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_init() }
+func file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_init() {
+	if File_github_com_aperturerobotics_starpc_e2e_mock_mock_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MockMsg); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_goTypes,
+		DependencyIndexes: file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_depIdxs,
+		MessageInfos:      file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_msgTypes,
+	}.Build()
+	File_github_com_aperturerobotics_starpc_e2e_mock_mock_proto = out.File
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_rawDesc = nil
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_goTypes = nil
+	file_github_com_aperturerobotics_starpc_e2e_mock_mock_proto_depIdxs = nil
+}