dynamic

type Client interface {
	// Returns isCommitted, the accepted time slot, execRet
	PaxosPropose(c *Command, leader string) (bool, string)

	// Returns isCommitted, isFast, the accepted time slot, execRet
	FastPaxosPropose(
		c *Command, shard int32, leader string, followerList []string, t int64,
	) (bool, bool, string)

	// Fast Paxos all leaners, for reducing execution latency
	ExecFastPaxosPropose(
		c *Command, shard int32, leader, execReplica string, replicaList []string, t int64,
	) (bool, bool, string)

	// Latency monitoring
	// Returns the queuing delay in ns and Paxos latency in ms
	Probe(addr string) (int64, int32)
	ProbeTime(addr string) (int64, int32)

	InitConn(addrList []string)

	// Shuts down
	Close()

	// Testing
	Test(addrList []string)
}

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

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

type ClientIo interface {
	InitConn(addrList []string)
	// Paxos, blocking RPC function
	SendPaxosProposeReq(addr string, cmd *Command) *PaxosProposeReply

	// Fast Paxos, non-blocking RPC functions
	BcstFpProposeToFollowers(addrList []string, req *FpProposeReq, fastC chan<- *FpProposeReply, wg *sync.WaitGroup)
	SendFpProposeToLeader(addr string, req *FpProposeReq, fastC, slowC chan<- *FpProposeReply, wg *sync.WaitGroup)
	// Fast Paxos with all replicas as learners, non-blocking RPC functions
	SendFpProposeToExecReplica(addr string, req *FpProposeReq, fastC, slowC chan<- *FpProposeReply, wg *sync.WaitGroup)

	// Latency monitoring
	SendProbeReq(addr string) *ProbeReply
	SendProbeTimeReq(addr string) *ProbeTimeReply

	// Testing
	SendTestReq(addr string)
}

type CmdEntry struct {
	Cmd    *Command
	T      *Timestamp
	Status int
}

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

type Command struct {
	Id   string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
	Key  string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
	Val  string `protobuf:"bytes,4,opt,name=val" json:"val,omitempty"`
}

type DynamicClient struct {

	// If the Fast Paxos leader uses Paxos to accept commonds that arerejected in
	// Fast Paxos instances
	IsFpLeaderUsePaxos bool
	// contains filtered or unexported fields
}

type DynamicPaxos struct {

	//Replica info
	ReplicaNum int
	Majority   int
	FastQuorum int

	// Network I/O swtich
	IsGrpc     bool // If using gRPC
	IsSyncSend bool // If doing server network I/O and computation in the same thread
	// contains filtered or unexported fields
}

type DynamicPaxosClient interface {
	// Multi-Paxos for clients
	PaxosPropose(ctx context.Context, in *PaxosProposeReq, opts ...grpc.CallOption) (*PaxosProposeReply, error)
	// Fast Paxos for clients
	FpPropose(ctx context.Context, in *FpProposeReq, opts ...grpc.CallOption) (DynamicPaxos_FpProposeClient, error)
	// Communication between replicas
	// Heart beat
	// Paxos Accept & Commit
	// Fast Paxos Vote
	// Fast Paxos Accept & Commit
	// Any above message should piggyback a commit timestamp message for the shard.
	// This commit timestamp indicates that the replica guarantees that it will
	// not accept/commit any operation before the timestamp
	DeliverReplicaMsg(ctx context.Context, opts ...grpc.CallOption) (DynamicPaxos_DeliverReplicaMsgClient, error)
	// // Network Latency Monitoring
	// For clients
	Probe(ctx context.Context, in *ProbeReq, opts ...grpc.CallOption) (*ProbeReply, error)
	ProbeTime(ctx context.Context, in *ProbeReq, opts ...grpc.CallOption) (*ProbeTimeReply, error)
	// For replica servers
	ReplicaProbe(ctx context.Context, in *ProbeReq, opts ...grpc.CallOption) (*ReplicaProbeReply, error)
	// Testing
	Test(ctx context.Context, in *TestReq, opts ...grpc.CallOption) (*TestReply, error)
}

type DynamicPaxosServer interface {
	// Multi-Paxos for clients
	PaxosPropose(context.Context, *PaxosProposeReq) (*PaxosProposeReply, error)
	// Fast Paxos for clients
	FpPropose(*FpProposeReq, DynamicPaxos_FpProposeServer) error
	// Communication between replicas
	// Heart beat
	// Paxos Accept & Commit
	// Fast Paxos Vote
	// Fast Paxos Accept & Commit
	// Any above message should piggyback a commit timestamp message for the shard.
	// This commit timestamp indicates that the replica guarantees that it will
	// not accept/commit any operation before the timestamp
	DeliverReplicaMsg(DynamicPaxos_DeliverReplicaMsgServer) error
	// // Network Latency Monitoring
	// For clients
	Probe(context.Context, *ProbeReq) (*ProbeReply, error)
	ProbeTime(context.Context, *ProbeReq) (*ProbeTimeReply, error)
	// For replica servers
	ReplicaProbe(context.Context, *ProbeReq) (*ReplicaProbeReply, error)
	// Testing
	Test(context.Context, *TestReq) (*TestReply, error)
}

type DynamicPaxos_DeliverReplicaMsgClient interface {
	Send(*ReplicaMsg) error
	CloseAndRecv() (*EmptyReply, error)
	grpc.ClientStream
}

type DynamicPaxos_DeliverReplicaMsgServer interface {
	SendAndClose(*EmptyReply) error
	Recv() (*ReplicaMsg, error)
	grpc.ServerStream
}

type DynamicPaxos_FpProposeClient interface {
	Recv() (*FpProposeReply, error)
	grpc.ClientStream
}

type DynamicPaxos_FpProposeServer interface {
	Send(*FpProposeReply) error
	grpc.ServerStream
}

type EmptyReply struct {
}

type Entry interface {
	GetT() *Timestamp
	GetCmd() *Command
	GetStatus() int
	SetStatus(int)
}

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

type ExecRet struct {
	C chan string
}

type FastIo struct {
	PeerAddrList []string
	PeerNetIo    []NetIo
	Id           int // replica Id starting from 0
	N            int // number of replicas
	Listener     net.Listener
	// contains filtered or unexported fields
}

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

type FpCmdConsRet struct {
	T        int64
	CmdId    string
	IsAccept bool
	IsFast   bool
}

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

type FpCmdSlowConsRet struct {
	T        int64
	CmdIdMap map[string]bool
}

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

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

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

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

type FpProposal struct {
	Cmd  *Command
	FpT  *Timestamp
	RetC chan bool
}

type FpProposeReply struct {
	IsAccept bool   `protobuf:"varint,1,opt,name=isAccept" json:"isAccept,omitempty"`
	IsFast   bool   `protobuf:"varint,2,opt,name=isFast" json:"isFast,omitempty"`
	ExecRet  string `protobuf:"bytes,3,opt,name=execRet" json:"execRet,omitempty"`
	CmdId    string `protobuf:"bytes,4,opt,name=cmdId" json:"cmdId,omitempty"`
}

type FpProposeReq struct {
	Cmd         *Command   `protobuf:"bytes,1,opt,name=cmd" json:"cmd,omitempty"`
	Time        *Timestamp `protobuf:"bytes,2,opt,name=time" json:"time,omitempty"`
	IsExecReply bool       `protobuf:"varint,3,opt,name=isExecReply" json:"isExecReply,omitempty"`
}

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

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

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

type LatReq struct {
	RetC chan bool
}

type Log interface {
	PeekMin() (Entry, bool)
	PopMin() (Entry, bool)

	Put(t int64, e Entry)
	Get(t int64) (Entry, bool)

	Del(t int64)

	IsFpLog() bool

	// Testing
	Test()
}

type LogManager interface {
	//Updates the min execution time among all Paxos and Fast Paxos shards
	UpdatePaxosMinExecT(t *Timestamp)
	UpdateFpMinExecT(t *Timestamp) bool

	// Paxos
	PaxosAcceptCmd(t *Timestamp, cmd *Command)
	PaxosCommitCmd(t *Timestamp, cmdId string)

	// Fast Paxos
	// Fast-path accept a client's command
	FpFastAcceptCmd(t *Timestamp, cmd *Command) bool
	// Slow-path accept a command
	FpAcceptCmd(t *Timestamp, cmd *Command)
	// Fast-path / slow-path commit a command
	FpCommitCmd(t *Timestamp, cmd *Command, isFast bool)

	// Preapres a shard for execution
	PrepareShardExec(shard int32)

	// Execution
	Exec()
	GetExecCh() <-chan Entry

	// Testing
	Test()
}

type NetIo interface {
	SendMsg(msgType uint8, msg interface{}) error
	RecvMsg() (msgType uint8, msg interface{}, err error)
	SendByte(b uint8) error
	RecvByte() (uint8, error)
	Close() error
}

type Paxos interface {
	// Paxos assignes a request with a future time when the replication completes
	EnablePaxosFutureTime(s *Server)

	Start(hbDelay time.Duration)

	// Probing message for latency monitoring
	// Returns the queuing (i.e., processing delay)
	Probe() time.Duration

	// Returns isCommitted
	PaxosLeaderAccept(cmd *Command) bool

	// Returns isAccepted (A cmd gets rejected if the timestamp passes the current time)
	FpReplicaAccept(cmd *Command, fpT *Timestamp) bool

	// Processes messages between replicas
	ProcessReplicaMsg(msg *ReplicaMsg)

	// Fast Paxos shard leader waits for consensus result
	FpWaitConsensus(t int64, cmdId string) (bool, bool)

	// Returns the Paxos shard ID that this replica is the leader
	GetCurPaxosShard() int32

	// Returns the Fast Paxos shard ID that this replica is the leader
	GetCurFpShard() int32

	// Returns the command execution channel for applications
	GetExecCh() <-chan Entry

	// Returns RPC I/O handle TODO Decouples I/O from Paxos module
	GetIo() ReplicaIo

	// Testing
	Test()
}

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

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

type PaxosProposal struct {
	Cmd  *Command
	RetC chan bool
}

type PaxosProposeReply struct {
	IsCommit bool   `protobuf:"varint,1,opt,name=isCommit" json:"isCommit,omitempty"`
	ExecRet  string `protobuf:"bytes,2,opt,name=execRet" json:"execRet,omitempty"`
	CmdId    string `protobuf:"bytes,3,opt,name=cmdId" json:"cmdId,omitempty"`
}

type PaxosProposeReq struct {
	Cmd *Command `protobuf:"bytes,1,opt,name=cmd" json:"cmd,omitempty"`
}

type ProbeReply struct {
	QueuingDelay int64 `protobuf:"varint,1,opt,name=queuingDelay" json:"queuingDelay,omitempty"`
	PaxosLat     int32 `protobuf:"varint,2,opt,name=paxosLat" json:"paxosLat,omitempty"`
}

type ProbeReq struct {
}

type ProbeTimeReply struct {
	ProcessTime int64 `protobuf:"varint,1,opt,name=processTime" json:"processTime,omitempty"`
	PaxosLat    int32 `protobuf:"varint,2,opt,name=paxosLat" json:"paxosLat,omitempty"`
}

type ReplicaIo interface {
	InitConn(addrList []string, streamBufSize int)

	// A replica broadcasts heart beat to others
	BcstHb(addrList []string, nat int64, rId string, fpExecT *Timestamp)

	// Paxos shard leader
	BcstPaxosAcceptReq(addrList []string, t *Timestamp, cmd *Command, rId string, fpExecT *Timestamp)
	BcstPaxosFutureAcceptReq(addrList []string, t *Timestamp, cmd *Command, rId string, nat int64, fpExecT *Timestamp)
	// Piggybacks current commit time
	BcstPaxosCommitReq(addrList []string, t *Timestamp, cmdId string, nat int64, rId string, fpExecT *Timestamp)

	// Paxos shard follower
	// Piggybacks current commit time
	SendPaxosAcceptReply(addr string, t *Timestamp, cmdId string, nat int64, rId string, fpExecT *Timestamp)

	// Fast Paxos shard leader
	BcstFpAccept(addrList []string, t *Timestamp, cmd *Command, execT *Timestamp, nat int64, rId string)
	BcstFpCommit(addrList []string, t *Timestamp, cmd *Command, isFast bool, execT *Timestamp, nat int64, rId string)

	// Fast Paxos all learners
	BcstFpFastVote(addrList []string, t *Timestamp, cmd *Command, isFastAccept bool, nat int64, rId string)

	// Fast Paxos shard follower
	SendFpFastVote(addr string, t *Timestamp, cmd *Command, isFastAccept bool, nat int64, rId string)
	SendFpAcceptReply(addr string, t *Timestamp, cmdId string, nat int64, rId string)

	// Blocking
	// Synchronous I/O Latency probing
	// TODO to be piggybacked on the heart beat message
	SyncSendReplicaProbeReq(addr string) *ReplicaProbeReply
}

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

type ReplicaMsg struct {
	Type       int32      `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
	Cmd        *Command   `protobuf:"bytes,2,opt,name=cmd" json:"cmd,omitempty"`
	Time       *Timestamp `protobuf:"bytes,3,opt,name=time" json:"time,omitempty"`
	IsAccept   bool       `protobuf:"varint,4,opt,name=isAccept" json:"isAccept,omitempty"`
	NonAcceptT int64      `protobuf:"varint,5,opt,name=nonAcceptT" json:"nonAcceptT,omitempty"`
	ReplicaId  string     `protobuf:"bytes,6,opt,name=replicaId" json:"replicaId,omitempty"`
	FpExecT    *Timestamp `protobuf:"bytes,7,opt,name=fpExecT" json:"fpExecT,omitempty"`
}

type ReplicaProbeReply struct {
	QueuingDelay int64 `protobuf:"varint,1,opt,name=queuingDelay" json:"queuingDelay,omitempty"`
}

type RpcIo interface {
	InitConn(addrList []string, streamBufSize int)

	// FIFO communication and processing between replicas
	BcstReplicaMsg(addrList []string, msg *ReplicaMsg)
	SendReplicaMsg(addr string, msg *ReplicaMsg)

	// Synchoronous I/O Latency probing (not FIFO processing)
	SendReplicaProbeReq(addr string) *ReplicaProbeReply
	// contains filtered or unexported methods
}

type Server struct {
	IsExecReply bool // True if reply execution ret

	IsFpLeaderUsePaxos bool
	IsFpLeaderLearner  bool

	IsGrpc bool

	// Latency predictions
	IsLatPrediction bool
	// contains filtered or unexported fields
}

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

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

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

type TestReply struct {
}

type TestReq struct {
}

type TimeManager interface {
	GetCurrentTime() int64
	PrevT(t int64) int64
	NextT(t int64) int64
}

type Timestamp struct {
	Time  int64 `protobuf:"varint,1,opt,name=time" json:"time,omitempty"`
	Shard int32 `protobuf:"varint,2,opt,name=shard" json:"shard,omitempty"`
}