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.
Source Files