p2p

type MessageClient interface {
	// Run should be executed in a dedicated goroutine and it would block unless an irrecoverable error has been encountered.
	Run(ctx context.Context, network string, addr string, receiverID NodeID, credential *security.Credential) (ret error)

	// SendMessage sends a message of a given topic. It would block if the inner channel is congested.
	SendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error)

	// TrySendMessage tries to send a message of a given topic. It will return an error if the inner channel is congested.
	TrySendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error)

	// CurrentAck is used to query the latest sequence number for a topic that is acknowledged by the server.
	// Note: currently only used for test.
	CurrentAck(topic Topic) (Seq, bool)
}

type MessageClientConfig struct {
	// The size of the sending channel used to buffer
	// messages before they go to gRPC.
	SendChannelSize int
	// The maximum duration for which messages wait to be batched.
	BatchSendInterval time.Duration
	// The maximum size in bytes of a batch.
	MaxBatchBytes int
	// The maximum number of messages in a batch.
	MaxBatchCount int
	// The limit of the rate at which the connection to the server is retried.
	RetryRateLimitPerSecond float64
	// The dial timeout for the gRPC client
	DialTimeout time.Duration
	// The advertised address of this node. Used for logging and monitoring purposes.
	AdvertisedAddr string
	// The version of the client for compatibility check.
	// It should be in semver format. Empty string means no check.
	ClientVersion string
	// MaxRecvMsgSize is the maximum message size in bytes TiCDC can receive.
	MaxRecvMsgSize int
}

type MessageClientStream = proto.CDCPeerToPeer_SendMessageClient

type MessageEntry = *proto.MessageEntry

type MessageRouter interface {
	// AddPeer should be invoked when a new peer is discovered.
	AddPeer(id NodeID, addr string)
	// RemovePeer should be invoked when a peer is determined to
	// be permanently unavailable.
	RemovePeer(id NodeID)
	// GetClient returns a MessageClient for `target`. It returns
	// nil if the target peer does not exist. The returned client
	// is canceled if RemovePeer is called on `target`.
	GetClient(target NodeID) MessageClient
	// GetLocalChannel returns a channel that can be used for intra-node communication.
	GetLocalChannel() <-chan RawMessageEntry
	// Close cancels all clients maintained internally and waits for all clients to exit.
	Close()
	// Err returns a channel to receive errors from.
	Err() <-chan error
}

type MessageServer struct {
	// contains filtered or unexported fields
}

type MessageServerConfig struct {
	// The maximum number of entries to be cached for topics with no handler registered
	MaxPendingMessageCountPerTopic int
	// The maximum number of unhandled internal tasks for the main thread.
	MaxPendingTaskCount int
	// The size of the channel for pending messages before sending them to gRPC.
	SendChannelSize int
	// The interval between ACKs.
	AckInterval time.Duration
	// The size of the goroutine pool for running the handlers.
	WorkerPoolSize int
	// The maximum send rate per stream (per peer).
	SendRateLimitPerStream float64
	// The maximum number of peers acceptable by this server
	MaxPeerCount int
	// Semver of the server. Empty string means no version check.
	ServerVersion string
	// MaxRecvMsgSize is the maximum message size in bytes TiCDC can receive.
	MaxRecvMsgSize int

	// After a duration of this time if the server doesn't see any activity it
	// pings the client to see if the transport is still alive.
	KeepAliveTime time.Duration

	// After having pinged for keepalive check, the server waits for a duration
	// of Timeout and if no activity is seen even after that the connection is
	// closed.
	KeepAliveTimeout time.Duration

	// The maximum time duration to wait before forcefully removing a handler.
	//
	// waitUnregisterHandleTimeout specifies how long to wait for
	// the topic handler to consume all pending messages before
	// forcefully unregister the handler.
	// For a correct implementation of the handler, the time it needs
	// to consume these messages is minimal, as the handler is not
	// expected to block on channels, etc.
	WaitUnregisterHandleTimeoutThreshold time.Duration
}

type MessageServerStream = proto.CDCPeerToPeer_SendMessageServer

type MockCluster struct {
	Nodes map[NodeID]*MockNode
}

type MockNode struct {
	Addr string
	ID   NodeID

	Server *MessageServer
	Router MessageRouter
	// contains filtered or unexported fields
}

type NodeID = string

type RawMessageEntry struct {
	// contains filtered or unexported fields
}

type Seq = int64

type Serializable interface {
	Marshal() ([]byte, error)
	Unmarshal(data []byte) error
}

type ServerWrapper struct {
	// contains filtered or unexported fields
}

type Topic = string