wire

type AppendEntriesRequest struct {
	raft.AppendEntriesRequest
}

type AppendEntriesResponse struct {
	raft.AppendEntriesResponse
	Error error
}

type ApplyTransactionRequest struct {
	NodeID      raft.ServerID
	Transaction *storage.Transaction
}

type ApplyTransactionResponse struct{}

type ClientMessage interface {
	Message
	Client()
}

type ClientWire interface {
	Send(msg ClientMessage) error
	Receive() (ServerMessage, error)
	HandshakeRaft() error
	HandshakeRpc() error
}

type DiscoveryRequest struct {
	NodeID raft.ServerID
}

type DiscoveryResponse struct {
	NodeID    raft.ServerID
	IsNewNode bool
	Peers     []raft.ServerAddress
	Leader    raft.ServerAddress
}

type ErrorResponse struct {
	Error error
}

type HandshakeIntention = int32

type HandshakeRequest struct {
	Intention HandshakeIntention
}

type HandshakeResponse struct{}

type InstallSnapshotRequest struct {
	raft.InstallSnapshotRequest
	Snapshot []byte
}

type InstallSnapshotResponse struct {
	raft.InstallSnapshotResponse
	Error error
}

type Message interface {
	Encode() []byte
	Decode(src []byte) error
}

type NextObjectIdRequest struct {
	ObjectPath []byte
}

type NextObjectIdResponse struct {
	Identity uint8
}

type RaftClientMessage interface {
	ClientMessage
	Raft()
}

type RaftClientWire interface {
	Send(msg RaftClientMessage) error
	Receive() (RaftServerMessage, error)
}

type RaftServerMessage interface {
	ServerMessage
	Raft()
}

type RaftServerWire interface {
	Send(msg RaftServerMessage) error
	Receive() (RaftClientMessage, error)
}

type RequestVoteRequest struct {
	raft.RequestVoteRequest
}

type RequestVoteResponse struct {
	raft.RequestVoteResponse
	Error error
}

type RpcClientMessage interface {
	ClientMessage
	RPC()
}

type RpcClientWire interface {
	Send(msg RpcClientMessage) error
	Receive() (RpcServerMessage, error)
}

type RpcServerMessage interface {
	ServerMessage
	RPC()
}

type RpcServerWire interface {
	Send(msg RpcServerMessage) error
	Receive() (RpcClientMessage, error)
}

type ServerMessage interface {
	Message
	Server()
}

type ServerWire interface {
	Send(msg ServerMessage) error
	Receive() (ClientMessage, error)
}