mirror of
https://github.com/minio/minio.git
synced 2024-12-27 15:45:55 -05:00
2aa18cafc6
With CoreDNS now supporting etcdv3 as the DNS backend, we can update our federation target to etcdv3. Users will now be able to use etcdv3 server as the federation backbone. Minio will update bucket data to etcdv3 and CoreDNS can pick that data up and serve it as bucket style DNS path.
78 lines
4.0 KiB
Go
78 lines
4.0 KiB
Go
/*
|
|
*
|
|
* Copyright 2016 gRPC authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
package grpc
|
|
|
|
import (
|
|
"golang.org/x/net/context"
|
|
)
|
|
|
|
// UnaryInvoker is called by UnaryClientInterceptor to complete RPCs.
|
|
type UnaryInvoker func(ctx context.Context, method string, req, reply interface{}, cc *ClientConn, opts ...CallOption) error
|
|
|
|
// UnaryClientInterceptor intercepts the execution of a unary RPC on the client. invoker is the handler to complete the RPC
|
|
// and it is the responsibility of the interceptor to call it.
|
|
// This is an EXPERIMENTAL API.
|
|
type UnaryClientInterceptor func(ctx context.Context, method string, req, reply interface{}, cc *ClientConn, invoker UnaryInvoker, opts ...CallOption) error
|
|
|
|
// Streamer is called by StreamClientInterceptor to create a ClientStream.
|
|
type Streamer func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error)
|
|
|
|
// StreamClientInterceptor intercepts the creation of ClientStream. It may return a custom ClientStream to intercept all I/O
|
|
// operations. streamer is the handler to create a ClientStream and it is the responsibility of the interceptor to call it.
|
|
// This is an EXPERIMENTAL API.
|
|
type StreamClientInterceptor func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, streamer Streamer, opts ...CallOption) (ClientStream, error)
|
|
|
|
// UnaryServerInfo consists of various information about a unary RPC on
|
|
// server side. All per-rpc information may be mutated by the interceptor.
|
|
type UnaryServerInfo struct {
|
|
// Server is the service implementation the user provides. This is read-only.
|
|
Server interface{}
|
|
// FullMethod is the full RPC method string, i.e., /package.service/method.
|
|
FullMethod string
|
|
}
|
|
|
|
// UnaryHandler defines the handler invoked by UnaryServerInterceptor to complete the normal
|
|
// execution of a unary RPC. If a UnaryHandler returns an error, it should be produced by the
|
|
// status package, or else gRPC will use codes.Unknown as the status code and err.Error() as
|
|
// the status message of the RPC.
|
|
type UnaryHandler func(ctx context.Context, req interface{}) (interface{}, error)
|
|
|
|
// UnaryServerInterceptor provides a hook to intercept the execution of a unary RPC on the server. info
|
|
// contains all the information of this RPC the interceptor can operate on. And handler is the wrapper
|
|
// of the service method implementation. It is the responsibility of the interceptor to invoke handler
|
|
// to complete the RPC.
|
|
type UnaryServerInterceptor func(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error)
|
|
|
|
// StreamServerInfo consists of various information about a streaming RPC on
|
|
// server side. All per-rpc information may be mutated by the interceptor.
|
|
type StreamServerInfo struct {
|
|
// FullMethod is the full RPC method string, i.e., /package.service/method.
|
|
FullMethod string
|
|
// IsClientStream indicates whether the RPC is a client streaming RPC.
|
|
IsClientStream bool
|
|
// IsServerStream indicates whether the RPC is a server streaming RPC.
|
|
IsServerStream bool
|
|
}
|
|
|
|
// StreamServerInterceptor provides a hook to intercept the execution of a streaming RPC on the server.
|
|
// info contains all the information of this RPC the interceptor can operate on. And handler is the
|
|
// service method implementation. It is the responsibility of the interceptor to invoke handler to
|
|
// complete the RPC.
|
|
type StreamServerInterceptor func(srv interface{}, ss ServerStream, info *StreamServerInfo, handler StreamHandler) error
|