starpc 0.0.1 → 0.1.2

package/dist/srpc/rpcproto.js

@@ -0,0 +1,322 @@
+/* eslint-disable */
+import Long from 'long';
+import * as _m0 from 'protobufjs/minimal';
+export const protobufPackage = 'srpc';
+function createBasePacket() {
+    return { body: undefined };
+}
+export const Packet = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.body?.$case === 'callStart') {
+            CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.body?.$case === 'callStartResp') {
+            CallStartResp.encode(message.body.callStartResp, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.body?.$case === 'callData') {
+            CallData.encode(message.body.callData, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePacket();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.body = {
+                        $case: 'callStart',
+                        callStart: CallStart.decode(reader, reader.uint32()),
+                    };
+                    break;
+                case 2:
+                    message.body = {
+                        $case: 'callStartResp',
+                        callStartResp: CallStartResp.decode(reader, reader.uint32()),
+                    };
+                    break;
+                case 3:
+                    message.body = {
+                        $case: 'callData',
+                        callData: CallData.decode(reader, reader.uint32()),
+                    };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            body: isSet(object.callStart)
+                ? {
+                    $case: 'callStart',
+                    callStart: CallStart.fromJSON(object.callStart),
+                }
+                : isSet(object.callStartResp)
+                    ? {
+                        $case: 'callStartResp',
+                        callStartResp: CallStartResp.fromJSON(object.callStartResp),
+                    }
+                    : isSet(object.callData)
+                        ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
+                        : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.body?.$case === 'callStart' &&
+            (obj.callStart = message.body?.callStart
+                ? CallStart.toJSON(message.body?.callStart)
+                : undefined);
+        message.body?.$case === 'callStartResp' &&
+            (obj.callStartResp = message.body?.callStartResp
+                ? CallStartResp.toJSON(message.body?.callStartResp)
+                : undefined);
+        message.body?.$case === 'callData' &&
+            (obj.callData = message.body?.callData
+                ? CallData.toJSON(message.body?.callData)
+                : undefined);
+        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 === 'callStartResp' &&
+            object.body?.callStartResp !== undefined &&
+            object.body?.callStartResp !== null) {
+            message.body = {
+                $case: 'callStartResp',
+                callStartResp: CallStartResp.fromPartial(object.body.callStartResp),
+            };
+        }
+        if (object.body?.$case === 'callData' &&
+            object.body?.callData !== undefined &&
+            object.body?.callData !== null) {
+            message.body = {
+                $case: 'callData',
+                callData: CallData.fromPartial(object.body.callData),
+            };
+        }
+        return message;
+    },
+};
+function createBaseCallStart() {
+    return { rpcService: '', rpcMethod: '', data: new Uint8Array() };
+}
+export const CallStart = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.rpcService !== '') {
+            writer.uint32(10).string(message.rpcService);
+        }
+        if (message.rpcMethod !== '') {
+            writer.uint32(18).string(message.rpcMethod);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(26).bytes(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCallStart();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.rpcService = reader.string();
+                    break;
+                case 2:
+                    message.rpcMethod = reader.string();
+                    break;
+                case 3:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    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(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.rpcService !== undefined && (obj.rpcService = message.rpcService);
+        message.rpcMethod !== undefined && (obj.rpcMethod = message.rpcMethod);
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseCallStart();
+        message.rpcService = object.rpcService ?? '';
+        message.rpcMethod = object.rpcMethod ?? '';
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+};
+function createBaseCallStartResp() {
+    return { error: '' };
+}
+export const CallStartResp = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.error !== '') {
+            writer.uint32(10).string(message.error);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCallStartResp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.error = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            error: isSet(object.error) ? String(object.error) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.error !== undefined && (obj.error = message.error);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseCallStartResp();
+        message.error = object.error ?? '';
+        return message;
+    },
+};
+function createBaseCallData() {
+    return { data: new Uint8Array(), complete: false, error: '' };
+}
+export const CallData = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.data.length !== 0) {
+            writer.uint32(10).bytes(message.data);
+        }
+        if (message.complete === true) {
+            writer.uint32(16).bool(message.complete);
+        }
+        if (message.error !== '') {
+            writer.uint32(26).string(message.error);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCallData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.data = reader.bytes();
+                    break;
+                case 2:
+                    message.complete = reader.bool();
+                    break;
+                case 3:
+                    message.error = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+            complete: isSet(object.complete) ? Boolean(object.complete) : false,
+            error: isSet(object.error) ? String(object.error) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        message.complete !== undefined && (obj.complete = message.complete);
+        message.error !== undefined && (obj.error = message.error);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseCallData();
+        message.data = object.data ?? new Uint8Array();
+        message.complete = object.complete ?? false;
+        message.error = object.error ?? '';
+        return message;
+    },
+};
+var globalThis = (() => {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    throw 'Unable to locate global object';
+})();
+const atob = globalThis.atob ||
+    ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
+function bytesFromBase64(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+const btoa = globalThis.btoa ||
+    ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
+function base64FromBytes(arr) {
+    const bin = [];
+    arr.forEach((byte) => {
+        bin.push(String.fromCharCode(byte));
+    });
+    return btoa(bin.join(''));
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/srpc/stream.d.ts

@@ -0,0 +1,5 @@
+import type { Packet } from './rpcproto';
+import type { Duplex } from 'it-stream-types';
+export declare type PacketHandler = (packet: Packet) => Promise<void>;
+export declare type Stream = Duplex<Uint8Array>;
+export declare type OpenStreamFunc = () => Promise<Stream>;

package/dist/srpc/stream.js

@@ -0,0 +1 @@
+export {};

package/dist/srpc/ts-proto-rpc.d.ts

@@ -0,0 +1,7 @@
+import type { Observable } from 'rxjs';
+export interface TsProtoRpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Observable<Uint8Array>;
+}

package/dist/srpc/ts-proto-rpc.js

@@ -0,0 +1 @@
+export {};

package/dist/srpc/websocket.d.ts

@@ -0,0 +1,7 @@
+import { Conn } from './conn.js';
+import type WebSocket from 'isomorphic-ws';
+export declare class WebSocketConn extends Conn {
+    private socket;
+    constructor(socket: WebSocket);
+    getSocket(): WebSocket;
+}

package/dist/srpc/websocket.js

@@ -0,0 +1,18 @@
+import { Conn } from './conn.js';
+import { duplex } from 'it-ws';
+import { pipe } from 'it-pipe';
+// WebSocketConn implements a connection with a WebSocket.
+export class WebSocketConn extends Conn {
+    // socket is the web socket
+    socket;
+    constructor(socket) {
+        super();
+        this.socket = socket;
+        const socketDuplex = duplex(socket);
+        pipe(this.source, socketDuplex, this.sink);
+    }
+    // getSocket returns the websocket.
+    getSocket() {
+        return this.socket;
+    }
+}

package/e2e/e2e.go

@@ -0,0 +1 @@
+package e2e

package/e2e/e2e_test.go

@@ -0,0 +1,158 @@
+package e2e
+
+import (
+	"context"
+	"io"
+	"testing"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+	"github.com/pkg/errors"
+)
+
+// RunE2E runs an end to end test with a callback.
+func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
+	// construct the server
+	echoServer := &echo.EchoServer{}
+	mux := srpc.NewMux()
+	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
+		t.Fatal(err.Error())
+	}
+	server := srpc.NewServer(mux)
+
+	// construct the client
+	openStream := srpc.NewServerPipe(server)
+	client := srpc.NewClient(openStream)
+
+	// construct the client rpc interface
+	clientEcho := echo.NewSRPCEchoerClient(client)
+
+	// call
+	if err := cb(clientEcho); err != nil {
+		t.Fatal(err.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,
+		})
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		if out.GetBody() != bodyTxt {
+			t.Fatalf("expected %q got %q", bodyTxt, out.GetBody())
+		}
+		return nil
+	})
+}
+
+// CheckServerStream checks the server stream portion of the Echo test.
+func CheckServerStream(t *testing.T, out echo.SRPCEchoer_EchoServerStreamClient, req *echo.EchoMsg) error {
+	// expect to rx 5, then close
+	expectedRx := 5
+	totalExpected := expectedRx
+	for {
+		echoMsg, err := out.Recv()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		body := echoMsg.GetBody()
+		bodyTxt := req.GetBody()
+		if body != bodyTxt {
+			return errors.Errorf("expected %q got %q", bodyTxt, body)
+		}
+		t.Logf("server->client message %d/%d", totalExpected-expectedRx+1, totalExpected)
+		expectedRx--
+	}
+	if expectedRx < 0 {
+		return errors.Errorf("got %d more messages than expected", -1*expectedRx)
+	}
+	return nil
+}
+
+func TestE2E_ServerStream(t *testing.T) {
+	ctx := context.Background()
+	RunE2E(t, func(client echo.SRPCEchoerClient) error {
+		bodyTxt := "hello world"
+		req := &echo.EchoMsg{
+			Body: bodyTxt,
+		}
+		out, err := client.EchoServerStream(ctx, req)
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		return CheckServerStream(t, out, req)
+	})
+}
+
+// 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
+	if err := out.MsgSend(req); err != nil {
+		return err
+	}
+	// expect 1 response
+	ret := &echo.EchoMsg{}
+	if err := out.MsgRecv(ret); err != nil {
+		return err
+	}
+	// check response
+	if ret.GetBody() != req.GetBody() {
+		return errors.Errorf("expected %q got %q", req.GetBody(), ret.GetBody())
+	}
+	_ = out.Close()
+	return nil
+}
+
+func TestE2E_ClientStream(t *testing.T) {
+	ctx := context.Background()
+	RunE2E(t, func(client echo.SRPCEchoerClient) error {
+		bodyTxt := "hello world"
+		req := &echo.EchoMsg{
+			Body: bodyTxt,
+		}
+		out, err := client.EchoClientStream(ctx)
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		return CheckClientStream(t, out, req)
+	})
+}
+
+func TestE2E_BidiStream(t *testing.T) {
+	ctx := context.Background()
+	RunE2E(t, func(client echo.SRPCEchoerClient) error {
+		strm, err := client.EchoBidiStream(ctx)
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		clientExpected := "hello from client"
+		if err := strm.MsgSend(&echo.EchoMsg{Body: clientExpected}); err != nil {
+			t.Fatal(err.Error())
+		}
+		msg, err := strm.Recv()
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		expected := "hello from server"
+		if msg.GetBody() != expected {
+			t.Fatalf("expected %q got %q", expected, msg.GetBody())
+		}
+		msg, err = strm.Recv()
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		if msg.GetBody() != clientExpected {
+			t.Fatalf("expected %q got %q", clientExpected, msg.GetBody())
+		}
+		// expect no error closing
+		return strm.Close()
+	})
+}

package/echo/echo.go

@@ -0,0 +1 @@
+package echo

package/echo/echo.pb.go

@@ -0,0 +1,165 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.1-devel
+// 	protoc        v3.19.3
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+
+package echo
+
+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)
+)
+
+// EchoMsg is the message body for Echo.
+type EchoMsg struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Body string `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (x *EchoMsg) Reset() {
+	*x = EchoMsg{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_github_com_aperturerobotics_starpc_echo_echo_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EchoMsg) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EchoMsg) ProtoMessage() {}
+
+func (x *EchoMsg) ProtoReflect() protoreflect.Message {
+	mi := &file_github_com_aperturerobotics_starpc_echo_echo_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 EchoMsg.ProtoReflect.Descriptor instead.
+func (*EchoMsg) Descriptor() ([]byte, []int) {
+	return file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *EchoMsg) GetBody() string {
+	if x != nil {
+		return x.Body
+	}
+	return ""
+}
+
+var File_github_com_aperturerobotics_starpc_echo_echo_proto protoreflect.FileDescriptor
+
+var file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDesc = []byte{
+	0x0a, 0x32, 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, 0x63, 0x68, 0x6f, 0x2f, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x65, 0x63, 0x68, 0x6f, 0x22, 0x1d, 0x0a, 0x07, 0x45, 0x63,
+	0x68, 0x6f, 0x4d, 0x73, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x32, 0xca, 0x01, 0x0a, 0x06, 0x45, 0x63,
+	0x68, 0x6f, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x04, 0x45, 0x63, 0x68, 0x6f, 0x12, 0x0d, 0x2e, 0x65,
+	0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63,
+	0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x12, 0x32, 0x0a, 0x10, 0x45, 0x63,
+	0x68, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x0d,
+	0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e,
+	0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67, 0x30, 0x01, 0x12, 0x32,
+	0x0a, 0x10, 0x45, 0x63, 0x68, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73,
+	0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d, 0x73, 0x67,
+	0x28, 0x01, 0x12, 0x32, 0x0a, 0x0e, 0x45, 0x63, 0x68, 0x6f, 0x42, 0x69, 0x64, 0x69, 0x53, 0x74,
+	0x72, 0x65, 0x61, 0x6d, 0x12, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f,
+	0x4d, 0x73, 0x67, 0x1a, 0x0d, 0x2e, 0x65, 0x63, 0x68, 0x6f, 0x2e, 0x45, 0x63, 0x68, 0x6f, 0x4d,
+	0x73, 0x67, 0x28, 0x01, 0x30, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescOnce sync.Once
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescData = file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDesc
+)
+
+func file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescGZIP() []byte {
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescOnce.Do(func() {
+		file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescData = protoimpl.X.CompressGZIP(file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescData)
+	})
+	return file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDescData
+}
+
+var file_github_com_aperturerobotics_starpc_echo_echo_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_github_com_aperturerobotics_starpc_echo_echo_proto_goTypes = []interface{}{
+	(*EchoMsg)(nil), // 0: echo.EchoMsg
+}
+var file_github_com_aperturerobotics_starpc_echo_echo_proto_depIdxs = []int32{
+	0, // 0: echo.Echoer.Echo:input_type -> echo.EchoMsg
+	0, // 1: echo.Echoer.EchoServerStream:input_type -> echo.EchoMsg
+	0, // 2: echo.Echoer.EchoClientStream:input_type -> echo.EchoMsg
+	0, // 3: echo.Echoer.EchoBidiStream:input_type -> echo.EchoMsg
+	0, // 4: echo.Echoer.Echo:output_type -> echo.EchoMsg
+	0, // 5: echo.Echoer.EchoServerStream:output_type -> echo.EchoMsg
+	0, // 6: echo.Echoer.EchoClientStream:output_type -> echo.EchoMsg
+	0, // 7: echo.Echoer.EchoBidiStream:output_type -> echo.EchoMsg
+	4, // [4:8] is the sub-list for method output_type
+	0, // [0:4] 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_echo_echo_proto_init() }
+func file_github_com_aperturerobotics_starpc_echo_echo_proto_init() {
+	if File_github_com_aperturerobotics_starpc_echo_echo_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_github_com_aperturerobotics_starpc_echo_echo_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*EchoMsg); 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_echo_echo_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_github_com_aperturerobotics_starpc_echo_echo_proto_goTypes,
+		DependencyIndexes: file_github_com_aperturerobotics_starpc_echo_echo_proto_depIdxs,
+		MessageInfos:      file_github_com_aperturerobotics_starpc_echo_echo_proto_msgTypes,
+	}.Build()
+	File_github_com_aperturerobotics_starpc_echo_echo_proto = out.File
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_rawDesc = nil
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_goTypes = nil
+	file_github_com_aperturerobotics_starpc_echo_echo_proto_depIdxs = nil
+}