Documentation ¶
Index ¶
- func CreateOutgoingContextWithPairs(ctx context.Context, pairs ...string) context.Context
- func GetLogicNodeFromContext(ctx context.Context) (models.Node, error)
- func GetStringFromContext(ctx context.Context, metaKey string) (string, error)
- type ClientConnFactory
- type ClientStreamFactory
- type ConnectionManager
- type GRPCServer
- type TaskClientFactory
- type TaskReceiver
- type TaskServerFactory
- type TransportManager
- type WriteStream
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func CreateOutgoingContextWithPairs ¶
CreateOutgoingContextWithPairs creates outGoing context with key, value pairs.
func GetLogicNodeFromContext ¶
GetLogicNodeFromContext returns the logicNode.
Types ¶
type ClientConnFactory ¶
type ClientConnFactory interface { // GetClientConn returns the grpc ClientConn for target node. // One connection for a target node. // Concurrent safe. GetClientConn(target models.Node) (*grpc.ClientConn, error) // CloseClientConn closes client connection for spec target node. CloseClientConn(target models.Node) error }
ClientConnFactory is the factory for grpc ClientConn.
func GetBrokerClientConnFactory ¶
func GetBrokerClientConnFactory() ClientConnFactory
GetBrokerClientConnFactory returns a singleton ClientConnFactory for broker side.
func GetRootClientConnFactory ¶ added in v0.2.4
func GetRootClientConnFactory() ClientConnFactory
GetRootClientConnFactory returns a singleton ClientConnFactory for root side.
func GetStorageClientConnFactory ¶
func GetStorageClientConnFactory() ClientConnFactory
GetStorageClientConnFactory returns a singleton ClientConnFactory for storage side.
type ClientStreamFactory ¶
type ClientStreamFactory interface { // LogicNode returns the logic Node which will be transferred to the target server for identification. LogicNode() models.Node // CreateTaskClient creates a stream task client CreateTaskClient(target models.Node) (protoCommonV1.TaskService_HandleClient, error) // CreateReplicaServiceClient creates a protoReplicaV1.ReplicaServiceClient. CreateReplicaServiceClient(target models.Node) (protoReplicaV1.ReplicaServiceClient, error) // CreateWriteServiceClient creates a protoWriteV1.WriteServiceClient. CreateWriteServiceClient(target models.Node) (protoWriteV1.WriteServiceClient, error) }
ClientStreamFactory is the factory to get ClientStream.
func NewClientStreamFactory ¶
func NewClientStreamFactory(ctx context.Context, logicNode models.Node, connFct ClientConnFactory) ClientStreamFactory
NewClientStreamFactory returns a factory to get clientStream.
type ConnectionManager ¶
type ConnectionManager interface { io.Closer // CreateConnection creates a grpc connection. CreateConnection(target models.Node) // CloseConnection closes a grpc connection. CloseConnection(target models.Node) }
ConnectionManager represents grpc connection manager.
func NewConnectionManager ¶
func NewConnectionManager(taskClientFct TaskClientFactory) ConnectionManager
NewConnectionManager creates a ConnectionManager instance.
type GRPCServer ¶
type GRPCServer interface { // Start starts grpc server Start() error // Stop stops grpc server Stop() // GetServer returns the grpc server GetServer() *grpc.Server }
func NewGRPCServer ¶
func NewGRPCServer(cfg config.GRPC, r *linmetric.Registry) GRPCServer
type TaskClientFactory ¶
type TaskClientFactory interface { // CreateTaskClient creates a task client stream if not exist CreateTaskClient(target models.Node) error // GetTaskClient returns the task client stream by target node GetTaskClient(target string) protoCommonV1.TaskService_HandleClient // CloseTaskClient closes the task client stream for target node CloseTaskClient(targetNodeID string) (closed bool, err error) // SetTaskReceiver set task receiver for handling task response SetTaskReceiver(taskReceiver TaskReceiver) }
TaskClientFactory represents the task stream manage
func NewTaskClientFactory ¶
func NewTaskClientFactory(ctx context.Context, currentNode models.Node, connFct ClientConnFactory) TaskClientFactory
NewTaskClientFactory creates a task client factory
type TaskReceiver ¶
type TaskReceiver interface { // Receive receives the task result Receive(resp *protoCommonV1.TaskResponse, fromNode string) error }
TaskReceiver represents the task result receiver
type TaskServerFactory ¶
type TaskServerFactory interface { // GetStream returns a ServerStream for a node. GetStream(node string) protoCommonV1.TaskService_HandleServer // Register registers a stream for a node. Register(node string, stream protoCommonV1.TaskService_HandleServer) (epoch int64) // Deregister unregisters a stream for node, if returns true, unregister successfully. Deregister(epoch int64, node string) bool // Nodes returns all registered nodes. Nodes() []models.Node }
TaskServerFactory represents a factory to get server stream.
func NewTaskServerFactory ¶
func NewTaskServerFactory() TaskServerFactory
NewTaskServerFactory returns the singleton server stream factory
type TransportManager ¶ added in v0.2.4
type TransportManager interface { // SendRequest sends the task request to target node. SendRequest(targetNodeID string, req *protoCommonV1.TaskRequest) error // SendResponse sends the task response to target node. SendResponse(targetNodeID string, resp *protoCommonV1.TaskResponse) error }
TransportManager represents the request/response send manager.
type WriteStream ¶
type WriteStream interface { io.Closer // Send sends metric data to storage. Send(data []byte) error }
WriteStream represents the channel which writes metric to storage based on grpc stream, and receives write response in background.
func NewWriteStream ¶
func NewWriteStream( ctx context.Context, target models.Node, database string, shardState *models.ShardState, familyTime int64, fct ClientStreamFactory, ) (WriteStream, error)
NewWriteStream creates a WriteStream instance, initialize grpc connection(stream) and receive response task.