From d959ab54847f66341c0bc78f8b225af68e8af8e3 Mon Sep 17 00:00:00 2001 From: ginuerzh Date: Sun, 19 Nov 2023 14:21:32 +0800 Subject: [PATCH] add router plugin --- ingress/example/main.go | 8 +- ingress/proto/ingress.pb.go | 141 ++++++------ ingress/proto/ingress.proto | 12 +- ingress/proto/ingress_grpc.pb.go | 56 ++--- router/example/main.go | 46 ++++ router/proto/router.pb.go | 365 +++++++++++++++++++++++++++++++ router/proto/router.proto | 30 +++ router/proto/router_grpc.pb.go | 141 ++++++++++++ 8 files changed, 692 insertions(+), 107 deletions(-) create mode 100644 router/example/main.go create mode 100644 router/proto/router.pb.go create mode 100644 router/proto/router.proto create mode 100644 router/proto/router_grpc.pb.go diff --git a/ingress/example/main.go b/ingress/example/main.go index 62eadff..df6add2 100644 --- a/ingress/example/main.go +++ b/ingress/example/main.go @@ -19,14 +19,14 @@ type server struct { proto.UnimplementedIngressServer } -func (s *server) Get(ctx context.Context, in *proto.GetRequest) (*proto.GetReply, error) { - reply := &proto.GetReply{} +func (s *server) GetRule(ctx context.Context, in *proto.GetRuleRequest) (*proto.GetRuleReply, error) { + reply := &proto.GetRuleReply{} log.Printf("ingress get: %s", in.GetHost()) return reply, nil } -func (s *server) Set(ctx context.Context, in *proto.SetRequest) (*proto.SetReply, error) { - reply := &proto.SetReply{} +func (s *server) SetRule(ctx context.Context, in *proto.SetRuleRequest) (*proto.SetRuleReply, error) { + reply := &proto.SetRuleReply{} log.Printf("ingress set: %s -> %s", in.GetHost(), in.GetEndpoint()) return reply, nil diff --git a/ingress/proto/ingress.pb.go b/ingress/proto/ingress.pb.go index 8fb5f0b..0e0fec0 100644 --- a/ingress/proto/ingress.pb.go +++ b/ingress/proto/ingress.pb.go @@ -24,7 +24,7 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) -type GetRequest struct { +type GetRuleRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -32,8 +32,8 @@ type GetRequest struct { Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` } -func (x *GetRequest) Reset() { - *x = GetRequest{} +func (x *GetRuleRequest) Reset() { + *x = GetRuleRequest{} if protoimpl.UnsafeEnabled { mi := &file_ingress_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -41,13 +41,13 @@ func (x *GetRequest) Reset() { } } -func (x *GetRequest) String() string { +func (x *GetRuleRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetRequest) ProtoMessage() {} +func (*GetRuleRequest) ProtoMessage() {} -func (x *GetRequest) ProtoReflect() protoreflect.Message { +func (x *GetRuleRequest) ProtoReflect() protoreflect.Message { mi := &file_ingress_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -59,19 +59,19 @@ func (x *GetRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead. -func (*GetRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use GetRuleRequest.ProtoReflect.Descriptor instead. +func (*GetRuleRequest) Descriptor() ([]byte, []int) { return file_ingress_proto_rawDescGZIP(), []int{0} } -func (x *GetRequest) GetHost() string { +func (x *GetRuleRequest) GetHost() string { if x != nil { return x.Host } return "" } -type GetReply struct { +type GetRuleReply struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -79,8 +79,8 @@ type GetReply struct { Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` } -func (x *GetReply) Reset() { - *x = GetReply{} +func (x *GetRuleReply) Reset() { + *x = GetRuleReply{} if protoimpl.UnsafeEnabled { mi := &file_ingress_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -88,13 +88,13 @@ func (x *GetReply) Reset() { } } -func (x *GetReply) String() string { +func (x *GetRuleReply) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetReply) ProtoMessage() {} +func (*GetRuleReply) ProtoMessage() {} -func (x *GetReply) ProtoReflect() protoreflect.Message { +func (x *GetRuleReply) ProtoReflect() protoreflect.Message { mi := &file_ingress_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -106,19 +106,19 @@ func (x *GetReply) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetReply.ProtoReflect.Descriptor instead. -func (*GetReply) Descriptor() ([]byte, []int) { +// Deprecated: Use GetRuleReply.ProtoReflect.Descriptor instead. +func (*GetRuleReply) Descriptor() ([]byte, []int) { return file_ingress_proto_rawDescGZIP(), []int{1} } -func (x *GetReply) GetEndpoint() string { +func (x *GetRuleReply) GetEndpoint() string { if x != nil { return x.Endpoint } return "" } -type SetRequest struct { +type SetRuleRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -127,8 +127,8 @@ type SetRequest struct { Endpoint string `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"` } -func (x *SetRequest) Reset() { - *x = SetRequest{} +func (x *SetRuleRequest) Reset() { + *x = SetRuleRequest{} if protoimpl.UnsafeEnabled { mi := &file_ingress_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -136,13 +136,13 @@ func (x *SetRequest) Reset() { } } -func (x *SetRequest) String() string { +func (x *SetRuleRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SetRequest) ProtoMessage() {} +func (*SetRuleRequest) ProtoMessage() {} -func (x *SetRequest) ProtoReflect() protoreflect.Message { +func (x *SetRuleRequest) ProtoReflect() protoreflect.Message { mi := &file_ingress_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -154,26 +154,26 @@ func (x *SetRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SetRequest.ProtoReflect.Descriptor instead. -func (*SetRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use SetRuleRequest.ProtoReflect.Descriptor instead. +func (*SetRuleRequest) Descriptor() ([]byte, []int) { return file_ingress_proto_rawDescGZIP(), []int{2} } -func (x *SetRequest) GetHost() string { +func (x *SetRuleRequest) GetHost() string { if x != nil { return x.Host } return "" } -func (x *SetRequest) GetEndpoint() string { +func (x *SetRuleRequest) GetEndpoint() string { if x != nil { return x.Endpoint } return "" } -type SetReply struct { +type SetRuleReply struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -181,8 +181,8 @@ type SetReply struct { Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` } -func (x *SetReply) Reset() { - *x = SetReply{} +func (x *SetRuleReply) Reset() { + *x = SetRuleReply{} if protoimpl.UnsafeEnabled { mi := &file_ingress_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -190,13 +190,13 @@ func (x *SetReply) Reset() { } } -func (x *SetReply) String() string { +func (x *SetRuleReply) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SetReply) ProtoMessage() {} +func (*SetRuleReply) ProtoMessage() {} -func (x *SetReply) ProtoReflect() protoreflect.Message { +func (x *SetRuleReply) ProtoReflect() protoreflect.Message { mi := &file_ingress_proto_msgTypes[3] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -208,12 +208,12 @@ func (x *SetReply) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SetReply.ProtoReflect.Descriptor instead. -func (*SetReply) Descriptor() ([]byte, []int) { +// Deprecated: Use SetRuleReply.ProtoReflect.Descriptor instead. +func (*SetRuleReply) Descriptor() ([]byte, []int) { return file_ingress_proto_rawDescGZIP(), []int{3} } -func (x *SetReply) GetOk() bool { +func (x *SetRuleReply) GetOk() bool { if x != nil { return x.Ok } @@ -224,26 +224,29 @@ var File_ingress_proto protoreflect.FileDescriptor var file_ingress_proto_rawDesc = []byte{ 0x0a, 0x0d, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, - 0x05, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x20, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x22, 0x26, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x52, - 0x65, 0x70, 0x6c, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, - 0x22, 0x3c, 0x0a, 0x0a, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, - 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1a, - 0x0a, 0x08, 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x32, 0x5f, 0x0a, 0x07, 0x49, 0x6e, - 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x29, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x11, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x0f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x79, - 0x12, 0x29, 0x0a, 0x03, 0x53, 0x65, 0x74, 0x12, 0x11, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0f, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x42, 0x29, 0x5a, 0x27, 0x67, - 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x2d, 0x67, 0x6f, 0x73, - 0x74, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, - 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x05, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x24, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x22, 0x2a, 0x0a, 0x0c, + 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x1a, 0x0a, 0x08, + 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x40, 0x0a, 0x0e, 0x53, 0x65, 0x74, 0x52, + 0x75, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x0c, 0x53, 0x65, + 0x74, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x32, 0x77, 0x0a, 0x07, 0x49, 0x6e, + 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x35, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, + 0x12, 0x15, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x35, 0x0a, 0x07, + 0x53, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x15, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x53, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x65, + 0x70, 0x6c, 0x79, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x67, 0x6f, 0x2d, 0x67, 0x6f, 0x73, 0x74, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, + 0x2f, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -260,16 +263,16 @@ func file_ingress_proto_rawDescGZIP() []byte { var file_ingress_proto_msgTypes = make([]protoimpl.MessageInfo, 4) var file_ingress_proto_goTypes = []interface{}{ - (*GetRequest)(nil), // 0: proto.GetRequest - (*GetReply)(nil), // 1: proto.GetReply - (*SetRequest)(nil), // 2: proto.SetRequest - (*SetReply)(nil), // 3: proto.SetReply + (*GetRuleRequest)(nil), // 0: proto.GetRuleRequest + (*GetRuleReply)(nil), // 1: proto.GetRuleReply + (*SetRuleRequest)(nil), // 2: proto.SetRuleRequest + (*SetRuleReply)(nil), // 3: proto.SetRuleReply } var file_ingress_proto_depIdxs = []int32{ - 0, // 0: proto.Ingress.Get:input_type -> proto.GetRequest - 2, // 1: proto.Ingress.Set:input_type -> proto.SetRequest - 1, // 2: proto.Ingress.Get:output_type -> proto.GetReply - 3, // 3: proto.Ingress.Set:output_type -> proto.SetReply + 0, // 0: proto.Ingress.GetRule:input_type -> proto.GetRuleRequest + 2, // 1: proto.Ingress.SetRule:input_type -> proto.SetRuleRequest + 1, // 2: proto.Ingress.GetRule:output_type -> proto.GetRuleReply + 3, // 3: proto.Ingress.SetRule:output_type -> proto.SetRuleReply 2, // [2:4] is the sub-list for method output_type 0, // [0:2] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name @@ -284,7 +287,7 @@ func file_ingress_proto_init() { } if !protoimpl.UnsafeEnabled { file_ingress_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetRequest); i { + switch v := v.(*GetRuleRequest); i { case 0: return &v.state case 1: @@ -296,7 +299,7 @@ func file_ingress_proto_init() { } } file_ingress_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetReply); i { + switch v := v.(*GetRuleReply); i { case 0: return &v.state case 1: @@ -308,7 +311,7 @@ func file_ingress_proto_init() { } } file_ingress_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SetRequest); i { + switch v := v.(*SetRuleRequest); i { case 0: return &v.state case 1: @@ -320,7 +323,7 @@ func file_ingress_proto_init() { } } file_ingress_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SetReply); i { + switch v := v.(*SetRuleReply); i { case 0: return &v.state case 1: diff --git a/ingress/proto/ingress.proto b/ingress/proto/ingress.proto index 1a07e46..8e4d552 100644 --- a/ingress/proto/ingress.proto +++ b/ingress/proto/ingress.proto @@ -6,24 +6,24 @@ syntax = "proto3"; package proto; option go_package = "github.com/go-gost/plugin/ingress/proto"; -message GetRequest { +message GetRuleRequest { string host = 1; } -message GetReply { +message GetRuleReply { string endpoint = 1; } -message SetRequest { +message SetRuleRequest { string host = 1; string endpoint = 2; } -message SetReply { +message SetRuleReply { bool ok = 1; } service Ingress { - rpc Get(GetRequest) returns (GetReply); - rpc Set(SetRequest) returns (SetReply); + rpc GetRule(GetRuleRequest) returns (GetRuleReply); + rpc SetRule(SetRuleRequest) returns (SetRuleReply); } diff --git a/ingress/proto/ingress_grpc.pb.go b/ingress/proto/ingress_grpc.pb.go index cbac192..a586003 100644 --- a/ingress/proto/ingress_grpc.pb.go +++ b/ingress/proto/ingress_grpc.pb.go @@ -22,8 +22,8 @@ const _ = grpc.SupportPackageIsVersion7 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. type IngressClient interface { - Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetReply, error) - Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetReply, error) + GetRule(ctx context.Context, in *GetRuleRequest, opts ...grpc.CallOption) (*GetRuleReply, error) + SetRule(ctx context.Context, in *SetRuleRequest, opts ...grpc.CallOption) (*SetRuleReply, error) } type ingressClient struct { @@ -34,18 +34,18 @@ func NewIngressClient(cc grpc.ClientConnInterface) IngressClient { return &ingressClient{cc} } -func (c *ingressClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetReply, error) { - out := new(GetReply) - err := c.cc.Invoke(ctx, "/proto.Ingress/Get", in, out, opts...) +func (c *ingressClient) GetRule(ctx context.Context, in *GetRuleRequest, opts ...grpc.CallOption) (*GetRuleReply, error) { + out := new(GetRuleReply) + err := c.cc.Invoke(ctx, "/proto.Ingress/GetRule", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *ingressClient) Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetReply, error) { - out := new(SetReply) - err := c.cc.Invoke(ctx, "/proto.Ingress/Set", in, out, opts...) +func (c *ingressClient) SetRule(ctx context.Context, in *SetRuleRequest, opts ...grpc.CallOption) (*SetRuleReply, error) { + out := new(SetRuleReply) + err := c.cc.Invoke(ctx, "/proto.Ingress/SetRule", in, out, opts...) if err != nil { return nil, err } @@ -56,8 +56,8 @@ func (c *ingressClient) Set(ctx context.Context, in *SetRequest, opts ...grpc.Ca // All implementations must embed UnimplementedIngressServer // for forward compatibility type IngressServer interface { - Get(context.Context, *GetRequest) (*GetReply, error) - Set(context.Context, *SetRequest) (*SetReply, error) + GetRule(context.Context, *GetRuleRequest) (*GetRuleReply, error) + SetRule(context.Context, *SetRuleRequest) (*SetRuleReply, error) mustEmbedUnimplementedIngressServer() } @@ -65,11 +65,11 @@ type IngressServer interface { type UnimplementedIngressServer struct { } -func (UnimplementedIngressServer) Get(context.Context, *GetRequest) (*GetReply, error) { - return nil, status.Errorf(codes.Unimplemented, "method Get not implemented") +func (UnimplementedIngressServer) GetRule(context.Context, *GetRuleRequest) (*GetRuleReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRule not implemented") } -func (UnimplementedIngressServer) Set(context.Context, *SetRequest) (*SetReply, error) { - return nil, status.Errorf(codes.Unimplemented, "method Set not implemented") +func (UnimplementedIngressServer) SetRule(context.Context, *SetRuleRequest) (*SetRuleReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetRule not implemented") } func (UnimplementedIngressServer) mustEmbedUnimplementedIngressServer() {} @@ -84,38 +84,38 @@ func RegisterIngressServer(s grpc.ServiceRegistrar, srv IngressServer) { s.RegisterService(&Ingress_ServiceDesc, srv) } -func _Ingress_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetRequest) +func _Ingress_GetRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRuleRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(IngressServer).Get(ctx, in) + return srv.(IngressServer).GetRule(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/proto.Ingress/Get", + FullMethod: "/proto.Ingress/GetRule", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(IngressServer).Get(ctx, req.(*GetRequest)) + return srv.(IngressServer).GetRule(ctx, req.(*GetRuleRequest)) } return interceptor(ctx, in, info, handler) } -func _Ingress_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SetRequest) +func _Ingress_SetRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetRuleRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(IngressServer).Set(ctx, in) + return srv.(IngressServer).SetRule(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/proto.Ingress/Set", + FullMethod: "/proto.Ingress/SetRule", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(IngressServer).Set(ctx, req.(*SetRequest)) + return srv.(IngressServer).SetRule(ctx, req.(*SetRuleRequest)) } return interceptor(ctx, in, info, handler) } @@ -128,12 +128,12 @@ var Ingress_ServiceDesc = grpc.ServiceDesc{ HandlerType: (*IngressServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "Get", - Handler: _Ingress_Get_Handler, + MethodName: "GetRule", + Handler: _Ingress_GetRule_Handler, }, { - MethodName: "Set", - Handler: _Ingress_Set_Handler, + MethodName: "SetRule", + Handler: _Ingress_SetRule_Handler, }, }, Streams: []grpc.StreamDesc{}, diff --git a/router/example/main.go b/router/example/main.go new file mode 100644 index 0000000..1ccc7af --- /dev/null +++ b/router/example/main.go @@ -0,0 +1,46 @@ +package main + +import ( + "context" + "flag" + "fmt" + "log" + "net" + + "github.com/go-gost/plugin/router/proto" + "google.golang.org/grpc" +) + +var ( + port = flag.Int("port", 8000, "The server port") +) + +type server struct { + proto.UnimplementedRouterServer +} + +func (s *server) GetRoute(ctx context.Context, in *proto.GetRouteRequest) (*proto.GetRouteReply, error) { + reply := &proto.GetRouteReply{} + log.Printf("router get: dst=%s", in.GetDst()) + return reply, nil +} + +func (s *server) SetRoute(ctx context.Context, in *proto.SetRouteRequest) (*proto.SetRouteReply, error) { + reply := &proto.SetRouteReply{} + log.Printf("router set: %s -> %s", in.GetNet(), in.GetGateway()) + return reply, nil +} + +func main() { + flag.Parse() + lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port)) + if err != nil { + log.Fatalf("failed to listen: %v", err) + } + s := grpc.NewServer() + proto.RegisterRouterServer(s, &server{}) + log.Printf("server listening at %v", lis.Addr()) + if err := s.Serve(lis); err != nil { + log.Fatalf("failed to serve: %v", err) + } +} diff --git a/router/proto/router.pb.go b/router/proto/router.pb.go new file mode 100644 index 0000000..d03e692 --- /dev/null +++ b/router/proto/router.pb.go @@ -0,0 +1,365 @@ +// protoc --go_out=. --go_opt=paths=source_relative \ +// --go-grpc_out=. --go-grpc_opt=paths=source_relative \ +// router.proto + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v3.15.8 +// source: router.proto + +package proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +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) +) + +type GetRouteRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Dst string `protobuf:"bytes,1,opt,name=dst,proto3" json:"dst,omitempty"` +} + +func (x *GetRouteRequest) Reset() { + *x = GetRouteRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_router_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRouteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRouteRequest) ProtoMessage() {} + +func (x *GetRouteRequest) ProtoReflect() protoreflect.Message { + mi := &file_router_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 GetRouteRequest.ProtoReflect.Descriptor instead. +func (*GetRouteRequest) Descriptor() ([]byte, []int) { + return file_router_proto_rawDescGZIP(), []int{0} +} + +func (x *GetRouteRequest) GetDst() string { + if x != nil { + return x.Dst + } + return "" +} + +type GetRouteReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Net string `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"` + Gateway string `protobuf:"bytes,2,opt,name=gateway,proto3" json:"gateway,omitempty"` +} + +func (x *GetRouteReply) Reset() { + *x = GetRouteReply{} + if protoimpl.UnsafeEnabled { + mi := &file_router_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRouteReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRouteReply) ProtoMessage() {} + +func (x *GetRouteReply) ProtoReflect() protoreflect.Message { + mi := &file_router_proto_msgTypes[1] + 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 GetRouteReply.ProtoReflect.Descriptor instead. +func (*GetRouteReply) Descriptor() ([]byte, []int) { + return file_router_proto_rawDescGZIP(), []int{1} +} + +func (x *GetRouteReply) GetNet() string { + if x != nil { + return x.Net + } + return "" +} + +func (x *GetRouteReply) GetGateway() string { + if x != nil { + return x.Gateway + } + return "" +} + +type SetRouteRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Net string `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"` + Gateway string `protobuf:"bytes,2,opt,name=gateway,proto3" json:"gateway,omitempty"` +} + +func (x *SetRouteRequest) Reset() { + *x = SetRouteRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_router_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetRouteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetRouteRequest) ProtoMessage() {} + +func (x *SetRouteRequest) ProtoReflect() protoreflect.Message { + mi := &file_router_proto_msgTypes[2] + 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 SetRouteRequest.ProtoReflect.Descriptor instead. +func (*SetRouteRequest) Descriptor() ([]byte, []int) { + return file_router_proto_rawDescGZIP(), []int{2} +} + +func (x *SetRouteRequest) GetNet() string { + if x != nil { + return x.Net + } + return "" +} + +func (x *SetRouteRequest) GetGateway() string { + if x != nil { + return x.Gateway + } + return "" +} + +type SetRouteReply struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *SetRouteReply) Reset() { + *x = SetRouteReply{} + if protoimpl.UnsafeEnabled { + mi := &file_router_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetRouteReply) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetRouteReply) ProtoMessage() {} + +func (x *SetRouteReply) ProtoReflect() protoreflect.Message { + mi := &file_router_proto_msgTypes[3] + 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 SetRouteReply.ProtoReflect.Descriptor instead. +func (*SetRouteReply) Descriptor() ([]byte, []int) { + return file_router_proto_rawDescGZIP(), []int{3} +} + +func (x *SetRouteReply) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +var File_router_proto protoreflect.FileDescriptor + +var file_router_proto_rawDesc = []byte{ + 0x0a, 0x0c, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x23, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x64, 0x73, 0x74, 0x22, 0x3b, 0x0a, 0x0d, 0x47, 0x65, + 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6e, + 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6e, 0x65, 0x74, 0x12, 0x18, 0x0a, + 0x07, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x22, 0x3d, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x52, 0x6f, + 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6e, 0x65, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6e, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, + 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x67, + 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x22, 0x1f, 0x0a, 0x0d, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, + 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x32, 0x7c, 0x0a, 0x06, 0x52, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x12, 0x38, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x16, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x47, 0x65, + 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x38, 0x0a, 0x08, 0x53, + 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x16, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x14, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, + 0x52, 0x65, 0x70, 0x6c, 0x79, 0x42, 0x28, 0x5a, 0x26, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x2d, 0x67, 0x6f, 0x73, 0x74, 0x2f, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_router_proto_rawDescOnce sync.Once + file_router_proto_rawDescData = file_router_proto_rawDesc +) + +func file_router_proto_rawDescGZIP() []byte { + file_router_proto_rawDescOnce.Do(func() { + file_router_proto_rawDescData = protoimpl.X.CompressGZIP(file_router_proto_rawDescData) + }) + return file_router_proto_rawDescData +} + +var file_router_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_router_proto_goTypes = []interface{}{ + (*GetRouteRequest)(nil), // 0: proto.GetRouteRequest + (*GetRouteReply)(nil), // 1: proto.GetRouteReply + (*SetRouteRequest)(nil), // 2: proto.SetRouteRequest + (*SetRouteReply)(nil), // 3: proto.SetRouteReply +} +var file_router_proto_depIdxs = []int32{ + 0, // 0: proto.Router.GetRoute:input_type -> proto.GetRouteRequest + 2, // 1: proto.Router.SetRoute:input_type -> proto.SetRouteRequest + 1, // 2: proto.Router.GetRoute:output_type -> proto.GetRouteReply + 3, // 3: proto.Router.SetRoute:output_type -> proto.SetRouteReply + 2, // [2:4] is the sub-list for method output_type + 0, // [0:2] 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_router_proto_init() } +func file_router_proto_init() { + if File_router_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_router_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRouteRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_router_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRouteReply); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_router_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetRouteRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_router_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetRouteReply); 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_router_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_router_proto_goTypes, + DependencyIndexes: file_router_proto_depIdxs, + MessageInfos: file_router_proto_msgTypes, + }.Build() + File_router_proto = out.File + file_router_proto_rawDesc = nil + file_router_proto_goTypes = nil + file_router_proto_depIdxs = nil +} diff --git a/router/proto/router.proto b/router/proto/router.proto new file mode 100644 index 0000000..d0a89e3 --- /dev/null +++ b/router/proto/router.proto @@ -0,0 +1,30 @@ +// protoc --go_out=. --go_opt=paths=source_relative \ +// --go-grpc_out=. --go-grpc_opt=paths=source_relative \ +// router.proto + +syntax = "proto3"; +package proto; +option go_package = "github.com/go-gost/plugin/router/proto"; + +message GetRouteRequest { + string dst = 1; +} + +message GetRouteReply { + string net = 1; + string gateway = 2; +} + +message SetRouteRequest { + string net = 1; + string gateway = 2; +} + +message SetRouteReply { + bool ok = 1; +} + +service Router { + rpc GetRoute(GetRouteRequest) returns (GetRouteReply); + rpc SetRoute(SetRouteRequest) returns (SetRouteReply); +} diff --git a/router/proto/router_grpc.pb.go b/router/proto/router_grpc.pb.go new file mode 100644 index 0000000..8b65153 --- /dev/null +++ b/router/proto/router_grpc.pb.go @@ -0,0 +1,141 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.2.0 +// - protoc v3.15.8 +// source: router.proto + +package proto + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// RouterClient is the client API for Router service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type RouterClient interface { + GetRoute(ctx context.Context, in *GetRouteRequest, opts ...grpc.CallOption) (*GetRouteReply, error) + SetRoute(ctx context.Context, in *SetRouteRequest, opts ...grpc.CallOption) (*SetRouteReply, error) +} + +type routerClient struct { + cc grpc.ClientConnInterface +} + +func NewRouterClient(cc grpc.ClientConnInterface) RouterClient { + return &routerClient{cc} +} + +func (c *routerClient) GetRoute(ctx context.Context, in *GetRouteRequest, opts ...grpc.CallOption) (*GetRouteReply, error) { + out := new(GetRouteReply) + err := c.cc.Invoke(ctx, "/proto.Router/GetRoute", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *routerClient) SetRoute(ctx context.Context, in *SetRouteRequest, opts ...grpc.CallOption) (*SetRouteReply, error) { + out := new(SetRouteReply) + err := c.cc.Invoke(ctx, "/proto.Router/SetRoute", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// RouterServer is the server API for Router service. +// All implementations must embed UnimplementedRouterServer +// for forward compatibility +type RouterServer interface { + GetRoute(context.Context, *GetRouteRequest) (*GetRouteReply, error) + SetRoute(context.Context, *SetRouteRequest) (*SetRouteReply, error) + mustEmbedUnimplementedRouterServer() +} + +// UnimplementedRouterServer must be embedded to have forward compatible implementations. +type UnimplementedRouterServer struct { +} + +func (UnimplementedRouterServer) GetRoute(context.Context, *GetRouteRequest) (*GetRouteReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRoute not implemented") +} +func (UnimplementedRouterServer) SetRoute(context.Context, *SetRouteRequest) (*SetRouteReply, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetRoute not implemented") +} +func (UnimplementedRouterServer) mustEmbedUnimplementedRouterServer() {} + +// UnsafeRouterServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to RouterServer will +// result in compilation errors. +type UnsafeRouterServer interface { + mustEmbedUnimplementedRouterServer() +} + +func RegisterRouterServer(s grpc.ServiceRegistrar, srv RouterServer) { + s.RegisterService(&Router_ServiceDesc, srv) +} + +func _Router_GetRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRouteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RouterServer).GetRoute(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.Router/GetRoute", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RouterServer).GetRoute(ctx, req.(*GetRouteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Router_SetRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetRouteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RouterServer).SetRoute(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.Router/SetRoute", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RouterServer).SetRoute(ctx, req.(*SetRouteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Router_ServiceDesc is the grpc.ServiceDesc for Router service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Router_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "proto.Router", + HandlerType: (*RouterServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetRoute", + Handler: _Router_GetRoute_Handler, + }, + { + MethodName: "SetRoute", + Handler: _Router_SetRoute_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "router.proto", +}