move implementation to internal/ directory (#828)
This commit is contained in:
Christian Schwarz
committed by
GitHub
GitHub
parent
b9b9ad10cf
commit
908807bd59
@@ -0,0 +1,149 @@
|
||||
// Package grpcclientidentity makes the client identity
|
||||
// provided by github.com/zrepl/zrepl/daemon/transport/serve.{AuthenticatedListener,AuthConn}
|
||||
// available to gRPC service handlers.
|
||||
//
|
||||
// This goal is achieved through the combination of custom gRPC transport credentials and two interceptors
|
||||
// (i.e. middleware).
|
||||
//
|
||||
// For gRPC clients, the TransportCredentials + Dialer can be used to construct a gRPC client (grpc.ClientConn)
|
||||
// that uses a github.com/zrepl/zrepl/daemon/transport/connect.Connecter to connect to a server.
|
||||
//
|
||||
// The adaptors exposed by this package must be used together, and panic if they are not.
|
||||
// See package grpchelper for a more restrictive but safe example on how the adaptors should be composed.
|
||||
package grpcclientidentity
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/credentials"
|
||||
"google.golang.org/grpc/peer"
|
||||
|
||||
"github.com/zrepl/zrepl/internal/logger"
|
||||
"github.com/zrepl/zrepl/internal/transport"
|
||||
)
|
||||
|
||||
type Logger = logger.Logger
|
||||
|
||||
type GRPCDialFunction = func(context.Context, string) (net.Conn, error)
|
||||
|
||||
func NewDialer(logger Logger, connecter transport.Connecter) GRPCDialFunction {
|
||||
return func(ctx context.Context, s string) (conn net.Conn, e error) {
|
||||
nc, err := connecter.Connect(ctx)
|
||||
// TODO find better place (callback from gRPC?) where to log errors
|
||||
// we want the users to know, though
|
||||
if err != nil {
|
||||
logger.WithError(err).Error("cannot connect")
|
||||
}
|
||||
return nc, err
|
||||
}
|
||||
}
|
||||
|
||||
type authConnAuthType struct {
|
||||
clientIdentity string
|
||||
}
|
||||
|
||||
func (authConnAuthType) AuthType() string {
|
||||
return "AuthConn"
|
||||
}
|
||||
|
||||
type connecterAuthType struct{}
|
||||
|
||||
func (connecterAuthType) AuthType() string {
|
||||
return "connecter"
|
||||
}
|
||||
|
||||
type transportCredentials struct {
|
||||
logger Logger
|
||||
}
|
||||
|
||||
// Use on both sides as ServerOption or ClientOption.
|
||||
func NewTransportCredentials(log Logger) credentials.TransportCredentials {
|
||||
if log == nil {
|
||||
log = logger.NewNullLogger()
|
||||
}
|
||||
return &transportCredentials{log}
|
||||
}
|
||||
|
||||
func (c *transportCredentials) ClientHandshake(ctx context.Context, s string, rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) {
|
||||
c.logger.WithField("url", s).WithField("connType", fmt.Sprintf("%T", rawConn)).Debug("ClientHandshake")
|
||||
// do nothing, client credential is only for WithInsecure warning to go away
|
||||
// the authentication is done by the connecter
|
||||
return rawConn, &connecterAuthType{}, nil
|
||||
}
|
||||
|
||||
func (c *transportCredentials) ServerHandshake(rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) {
|
||||
c.logger.WithField("connType", fmt.Sprintf("%T", rawConn)).Debug("ServerHandshake")
|
||||
authConn, ok := rawConn.(*transport.AuthConn)
|
||||
if !ok {
|
||||
panic(fmt.Sprintf("NewTransportCredentials must be used with a listener that returns *transport.AuthConn, got %T", rawConn))
|
||||
}
|
||||
return rawConn, &authConnAuthType{authConn.ClientIdentity()}, nil
|
||||
}
|
||||
|
||||
func (*transportCredentials) Info() credentials.ProtocolInfo {
|
||||
return credentials.ProtocolInfo{} // TODO
|
||||
}
|
||||
|
||||
func (t *transportCredentials) Clone() credentials.TransportCredentials {
|
||||
var x = *t
|
||||
return &x
|
||||
}
|
||||
|
||||
func (*transportCredentials) OverrideServerName(string) error {
|
||||
panic("not implemented")
|
||||
}
|
||||
|
||||
type ContextInterceptorData interface {
|
||||
FullMethod() string
|
||||
ClientIdentity() string
|
||||
}
|
||||
|
||||
type contextInterceptorData struct {
|
||||
fullMethod string
|
||||
clientIdentity string
|
||||
}
|
||||
|
||||
func (d contextInterceptorData) FullMethod() string { return d.fullMethod }
|
||||
func (d contextInterceptorData) ClientIdentity() string { return d.clientIdentity }
|
||||
|
||||
type Interceptor = func(ctx context.Context, data ContextInterceptorData, handler func(ctx context.Context))
|
||||
|
||||
func NewInterceptors(logger Logger, clientIdentityKey interface{}, interceptor Interceptor) (unary grpc.UnaryServerInterceptor, stream grpc.StreamServerInterceptor) {
|
||||
unary = func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
|
||||
logger.WithField("fullMethod", info.FullMethod).Debug("request")
|
||||
p, ok := peer.FromContext(ctx)
|
||||
if !ok {
|
||||
panic("peer.FromContext expected to return a peer in grpc.UnaryServerInterceptor")
|
||||
}
|
||||
peerAddr := ""
|
||||
if p.Addr != nil { // https://github.com/zrepl/zrepl/issues/598
|
||||
peerAddr = p.Addr.String()
|
||||
}
|
||||
logger.WithField("peer_addr", peerAddr).Debug("peer addr")
|
||||
a, ok := p.AuthInfo.(*authConnAuthType)
|
||||
if !ok {
|
||||
panic(fmt.Sprintf("NewInterceptors must be used in combination with grpc.NewTransportCredentials, but got auth type %T", p.AuthInfo))
|
||||
}
|
||||
logger.WithField("peer_client_identity", a.clientIdentity).Debug("peer client identity")
|
||||
ctx = context.WithValue(ctx, clientIdentityKey, a.clientIdentity)
|
||||
data := contextInterceptorData{
|
||||
fullMethod: info.FullMethod,
|
||||
clientIdentity: a.clientIdentity,
|
||||
}
|
||||
var (
|
||||
resp interface{}
|
||||
err error
|
||||
)
|
||||
interceptor(ctx, data, func(ctx context.Context) {
|
||||
resp, err = handler(ctx, req) // no-shadow
|
||||
})
|
||||
return resp, err
|
||||
}
|
||||
stream = func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
|
||||
panic("unimplemented")
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
syntax = "proto3";
|
||||
option go_package = ".;pdu";
|
||||
|
||||
package pdu;
|
||||
|
||||
service Greeter {
|
||||
rpc Greet(GreetRequest) returns (GreetResponse) {}
|
||||
}
|
||||
|
||||
message GreetRequest {
|
||||
string name = 1;
|
||||
}
|
||||
|
||||
message GreetResponse {
|
||||
string msg = 1;
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
// This package demonstrates how the grpcclientidentity package can be used
|
||||
// to set up a gRPC greeter service.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/zrepl/zrepl/internal/config"
|
||||
"github.com/zrepl/zrepl/internal/logger"
|
||||
"github.com/zrepl/zrepl/internal/rpc/grpcclientidentity/example/pdu"
|
||||
"github.com/zrepl/zrepl/internal/rpc/grpcclientidentity/grpchelper"
|
||||
"github.com/zrepl/zrepl/internal/transport/tcp"
|
||||
)
|
||||
|
||||
var args struct {
|
||||
mode string
|
||||
}
|
||||
|
||||
var log = logger.NewStderrDebugLogger()
|
||||
|
||||
func main() {
|
||||
flag.StringVar(&args.mode, "mode", "", "client|server")
|
||||
flag.Parse()
|
||||
|
||||
switch args.mode {
|
||||
case "client":
|
||||
client()
|
||||
case "server":
|
||||
server()
|
||||
default:
|
||||
log.Printf("unknown mode %q")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func onErr(err error, format string, args ...interface{}) {
|
||||
log.WithError(err).Error(fmt.Sprintf("%s: %s", fmt.Sprintf(format, args...), err))
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
func client() {
|
||||
cn, err := tcp.TCPConnecterFromConfig(&config.TCPConnect{
|
||||
ConnectCommon: config.ConnectCommon{
|
||||
Type: "tcp",
|
||||
},
|
||||
Address: "127.0.0.1:8080",
|
||||
DialTimeout: 10 * time.Second,
|
||||
})
|
||||
if err != nil {
|
||||
onErr(err, "build connecter error")
|
||||
}
|
||||
|
||||
clientConn := grpchelper.ClientConn(cn, log)
|
||||
defer clientConn.Close()
|
||||
|
||||
// normal usage from here on
|
||||
|
||||
client := pdu.NewGreeterClient(clientConn)
|
||||
resp, err := client.Greet(context.Background(), &pdu.GreetRequest{Name: "somethingimadeup"})
|
||||
if err != nil {
|
||||
onErr(err, "RPC error")
|
||||
}
|
||||
|
||||
fmt.Printf("got response:\n\t%s\n", resp.GetMsg())
|
||||
}
|
||||
|
||||
const clientIdentityKey = "clientIdentity"
|
||||
|
||||
func server() {
|
||||
authListenerFactory, err := tcp.TCPListenerFactoryFromConfig(nil, &config.TCPServe{
|
||||
ServeCommon: config.ServeCommon{
|
||||
Type: "tcp",
|
||||
},
|
||||
Listen: "127.0.0.1:8080",
|
||||
Clients: map[string]string{
|
||||
"127.0.0.1": "localclient",
|
||||
"::1": "localclient",
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
onErr(err, "cannot build listener factory")
|
||||
}
|
||||
|
||||
log := logger.NewStderrDebugLogger()
|
||||
|
||||
authListener, err := authListenerFactory()
|
||||
if err != nil {
|
||||
onErr(err, "cannot listen")
|
||||
}
|
||||
|
||||
srv, serve := grpchelper.NewServer(authListener, clientIdentityKey, log, nil)
|
||||
|
||||
svc := &greeter{prepend: "hello "}
|
||||
pdu.RegisterGreeterServer(srv, svc)
|
||||
|
||||
if err := serve(); err != nil {
|
||||
onErr(err, "error serving")
|
||||
}
|
||||
}
|
||||
|
||||
type greeter struct {
|
||||
pdu.UnsafeGreeterServer
|
||||
prepend string
|
||||
}
|
||||
|
||||
func (g *greeter) Greet(ctx context.Context, r *pdu.GreetRequest) (*pdu.GreetResponse, error) {
|
||||
ci, _ := ctx.Value(clientIdentityKey).(string)
|
||||
log.WithField("clientIdentity", ci).Info("Greet() request") // show that we got the client identity
|
||||
return &pdu.GreetResponse{Msg: fmt.Sprintf("%s%s (clientIdentity=%q)", g.prepend, r.GetName(), ci)}, nil
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// versions:
|
||||
// protoc-gen-go v1.34.2
|
||||
// protoc v5.28.0
|
||||
// source: grpcauth.proto
|
||||
|
||||
package pdu
|
||||
|
||||
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 GreetRequest struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||||
}
|
||||
|
||||
func (x *GreetRequest) Reset() {
|
||||
*x = GreetRequest{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_grpcauth_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *GreetRequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*GreetRequest) ProtoMessage() {}
|
||||
|
||||
func (x *GreetRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_grpcauth_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 GreetRequest.ProtoReflect.Descriptor instead.
|
||||
func (*GreetRequest) Descriptor() ([]byte, []int) {
|
||||
return file_grpcauth_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *GreetRequest) GetName() string {
|
||||
if x != nil {
|
||||
return x.Name
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type GreetResponse struct {
|
||||
state protoimpl.MessageState
|
||||
sizeCache protoimpl.SizeCache
|
||||
unknownFields protoimpl.UnknownFields
|
||||
|
||||
Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
|
||||
}
|
||||
|
||||
func (x *GreetResponse) Reset() {
|
||||
*x = GreetResponse{}
|
||||
if protoimpl.UnsafeEnabled {
|
||||
mi := &file_grpcauth_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
}
|
||||
|
||||
func (x *GreetResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*GreetResponse) ProtoMessage() {}
|
||||
|
||||
func (x *GreetResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_grpcauth_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 GreetResponse.ProtoReflect.Descriptor instead.
|
||||
func (*GreetResponse) Descriptor() ([]byte, []int) {
|
||||
return file_grpcauth_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *GreetResponse) GetMsg() string {
|
||||
if x != nil {
|
||||
return x.Msg
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
var File_grpcauth_proto protoreflect.FileDescriptor
|
||||
|
||||
var file_grpcauth_proto_rawDesc = []byte{
|
||||
0x0a, 0x0e, 0x67, 0x72, 0x70, 0x63, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
|
||||
0x12, 0x03, 0x70, 0x64, 0x75, 0x22, 0x22, 0x0a, 0x0c, 0x47, 0x72, 0x65, 0x65, 0x74, 0x52, 0x65,
|
||||
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
|
||||
0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x21, 0x0a, 0x0d, 0x47, 0x72, 0x65,
|
||||
0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73,
|
||||
0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x32, 0x3b, 0x0a, 0x07,
|
||||
0x47, 0x72, 0x65, 0x65, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x05, 0x47, 0x72, 0x65, 0x65, 0x74,
|
||||
0x12, 0x11, 0x2e, 0x70, 0x64, 0x75, 0x2e, 0x47, 0x72, 0x65, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75,
|
||||
0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x70, 0x64, 0x75, 0x2e, 0x47, 0x72, 0x65, 0x65, 0x74, 0x52,
|
||||
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x07, 0x5a, 0x05, 0x2e, 0x3b, 0x70,
|
||||
0x64, 0x75, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
|
||||
}
|
||||
|
||||
var (
|
||||
file_grpcauth_proto_rawDescOnce sync.Once
|
||||
file_grpcauth_proto_rawDescData = file_grpcauth_proto_rawDesc
|
||||
)
|
||||
|
||||
func file_grpcauth_proto_rawDescGZIP() []byte {
|
||||
file_grpcauth_proto_rawDescOnce.Do(func() {
|
||||
file_grpcauth_proto_rawDescData = protoimpl.X.CompressGZIP(file_grpcauth_proto_rawDescData)
|
||||
})
|
||||
return file_grpcauth_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_grpcauth_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
|
||||
var file_grpcauth_proto_goTypes = []any{
|
||||
(*GreetRequest)(nil), // 0: pdu.GreetRequest
|
||||
(*GreetResponse)(nil), // 1: pdu.GreetResponse
|
||||
}
|
||||
var file_grpcauth_proto_depIdxs = []int32{
|
||||
0, // 0: pdu.Greeter.Greet:input_type -> pdu.GreetRequest
|
||||
1, // 1: pdu.Greeter.Greet:output_type -> pdu.GreetResponse
|
||||
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_grpcauth_proto_init() }
|
||||
func file_grpcauth_proto_init() {
|
||||
if File_grpcauth_proto != nil {
|
||||
return
|
||||
}
|
||||
if !protoimpl.UnsafeEnabled {
|
||||
file_grpcauth_proto_msgTypes[0].Exporter = func(v any, i int) any {
|
||||
switch v := v.(*GreetRequest); i {
|
||||
case 0:
|
||||
return &v.state
|
||||
case 1:
|
||||
return &v.sizeCache
|
||||
case 2:
|
||||
return &v.unknownFields
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
file_grpcauth_proto_msgTypes[1].Exporter = func(v any, i int) any {
|
||||
switch v := v.(*GreetResponse); 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_grpcauth_proto_rawDesc,
|
||||
NumEnums: 0,
|
||||
NumMessages: 2,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_grpcauth_proto_goTypes,
|
||||
DependencyIndexes: file_grpcauth_proto_depIdxs,
|
||||
MessageInfos: file_grpcauth_proto_msgTypes,
|
||||
}.Build()
|
||||
File_grpcauth_proto = out.File
|
||||
file_grpcauth_proto_rawDesc = nil
|
||||
file_grpcauth_proto_goTypes = nil
|
||||
file_grpcauth_proto_depIdxs = nil
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
||||
// versions:
|
||||
// - protoc-gen-go-grpc v1.5.1
|
||||
// - protoc v5.28.0
|
||||
// source: grpcauth.proto
|
||||
|
||||
package pdu
|
||||
|
||||
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.64.0 or later.
|
||||
const _ = grpc.SupportPackageIsVersion9
|
||||
|
||||
const (
|
||||
Greeter_Greet_FullMethodName = "/pdu.Greeter/Greet"
|
||||
)
|
||||
|
||||
// GreeterClient is the client API for Greeter 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 GreeterClient interface {
|
||||
Greet(ctx context.Context, in *GreetRequest, opts ...grpc.CallOption) (*GreetResponse, error)
|
||||
}
|
||||
|
||||
type greeterClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
|
||||
return &greeterClient{cc}
|
||||
}
|
||||
|
||||
func (c *greeterClient) Greet(ctx context.Context, in *GreetRequest, opts ...grpc.CallOption) (*GreetResponse, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(GreetResponse)
|
||||
err := c.cc.Invoke(ctx, Greeter_Greet_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// GreeterServer is the server API for Greeter service.
|
||||
// All implementations must embed UnimplementedGreeterServer
|
||||
// for forward compatibility.
|
||||
type GreeterServer interface {
|
||||
Greet(context.Context, *GreetRequest) (*GreetResponse, error)
|
||||
mustEmbedUnimplementedGreeterServer()
|
||||
}
|
||||
|
||||
// UnimplementedGreeterServer must be embedded to have
|
||||
// forward compatible implementations.
|
||||
//
|
||||
// NOTE: this should be embedded by value instead of pointer to avoid a nil
|
||||
// pointer dereference when methods are called.
|
||||
type UnimplementedGreeterServer struct{}
|
||||
|
||||
func (UnimplementedGreeterServer) Greet(context.Context, *GreetRequest) (*GreetResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method Greet not implemented")
|
||||
}
|
||||
func (UnimplementedGreeterServer) mustEmbedUnimplementedGreeterServer() {}
|
||||
func (UnimplementedGreeterServer) testEmbeddedByValue() {}
|
||||
|
||||
// UnsafeGreeterServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to GreeterServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeGreeterServer interface {
|
||||
mustEmbedUnimplementedGreeterServer()
|
||||
}
|
||||
|
||||
func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
|
||||
// If the following call pancis, it indicates UnimplementedGreeterServer was
|
||||
// embedded by pointer and is nil. This will cause panics if an
|
||||
// unimplemented method is ever invoked, so we test this at initialization
|
||||
// time to prevent it from happening at runtime later due to I/O.
|
||||
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
|
||||
t.testEmbeddedByValue()
|
||||
}
|
||||
s.RegisterService(&Greeter_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _Greeter_Greet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GreetRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(GreeterServer).Greet(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: Greeter_Greet_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(GreeterServer).Greet(ctx, req.(*GreetRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
// Greeter_ServiceDesc is the grpc.ServiceDesc for Greeter service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var Greeter_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "pdu.Greeter",
|
||||
HandlerType: (*GreeterServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "Greet",
|
||||
Handler: _Greeter_Greet_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{},
|
||||
Metadata: "grpcauth.proto",
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
// Package grpchelper wraps the adaptors implemented by package grpcclientidentity into a less flexible API
|
||||
// which, however, ensures that the individual adaptor primitive's expectations are met and hence do not panic.
|
||||
package grpchelper
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/keepalive"
|
||||
|
||||
"github.com/zrepl/zrepl/internal/logger"
|
||||
"github.com/zrepl/zrepl/internal/rpc/grpcclientidentity"
|
||||
"github.com/zrepl/zrepl/internal/rpc/netadaptor"
|
||||
"github.com/zrepl/zrepl/internal/transport"
|
||||
)
|
||||
|
||||
// The following constants are relevant for interoperability.
|
||||
// We use the same values for client & server, because zrepl is more
|
||||
// symmetrical ("one source, one sink") instead of the typical
|
||||
// gRPC scenario ("many clients, single server")
|
||||
const (
|
||||
StartKeepalivesAfterInactivityDuration = 5 * time.Second
|
||||
KeepalivePeerTimeout = 10 * time.Second
|
||||
)
|
||||
|
||||
type Logger = logger.Logger
|
||||
|
||||
// ClientConn is an easy-to-use wrapper around the Dialer and TransportCredentials interface
|
||||
// to produce a grpc.ClientConn
|
||||
func ClientConn(cn transport.Connecter, log Logger) *grpc.ClientConn {
|
||||
ka := grpc.WithKeepaliveParams(keepalive.ClientParameters{
|
||||
Time: StartKeepalivesAfterInactivityDuration,
|
||||
Timeout: KeepalivePeerTimeout,
|
||||
PermitWithoutStream: true,
|
||||
})
|
||||
dialerOption := grpc.WithContextDialer(grpcclientidentity.NewDialer(log, cn))
|
||||
cred := grpc.WithTransportCredentials(grpcclientidentity.NewTransportCredentials(log))
|
||||
// we use context.Background without a timeout here because we don't set grpc.WithBlock
|
||||
// => docs: "In the non-blocking case, the ctx does not act against the connection. It only controls the setup steps."
|
||||
cc, err := grpc.NewClient("passthrough://doesntmatterdonebydialer", dialerOption, cred, ka)
|
||||
if err != nil {
|
||||
log.WithError(err).Error("cannot create gRPC client conn (non-blocking)")
|
||||
// It's ok to panic here: the we call grpc.DialContext without the
|
||||
// (grpc.WithBlock) dial option, and at the time of writing, the grpc
|
||||
// docs state that no connection attempt is made in that case.
|
||||
// Hence, any error that occurs is due to DialOptions or similar,
|
||||
// and thus indicative of an implementation error.
|
||||
panic(err)
|
||||
}
|
||||
return cc
|
||||
}
|
||||
|
||||
// NewServer is a convenience interface around the TransportCredentials and Interceptors interface.
|
||||
func NewServer(authListener transport.AuthenticatedListener, clientIdentityKey interface{}, logger grpcclientidentity.Logger, ctxInterceptor grpcclientidentity.Interceptor) (srv *grpc.Server, serve func() error) {
|
||||
ka := grpc.KeepaliveParams(keepalive.ServerParameters{
|
||||
Time: StartKeepalivesAfterInactivityDuration,
|
||||
Timeout: KeepalivePeerTimeout,
|
||||
})
|
||||
ep := grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
|
||||
MinTime: StartKeepalivesAfterInactivityDuration / 2, // avoid skew
|
||||
PermitWithoutStream: true,
|
||||
})
|
||||
tcs := grpcclientidentity.NewTransportCredentials(logger)
|
||||
unary, stream := grpcclientidentity.NewInterceptors(logger, clientIdentityKey, ctxInterceptor)
|
||||
srv = grpc.NewServer(grpc.Creds(tcs), grpc.UnaryInterceptor(unary), grpc.StreamInterceptor(stream), ka, ep)
|
||||
|
||||
serve = func() error {
|
||||
if err := srv.Serve(netadaptor.New(authListener, logger)); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
return srv, serve
|
||||
}
|
||||
Reference in New Issue
Block a user