paxi

type AdminClient interface {
	Consensus(Key) bool
	Crash(ID, int)
	Drop(ID, ID, int)
	Partition(int, ...ID)
}

type Ballot uint64

type Bconfig struct {
	T                    int     // total number of running time in seconds
	N                    int     // total number of requests
	K                    int     // key sapce
	W                    float64 // write ratio
	Throttle             int     // requests per second throttle, unused if 0
	Concurrency          int     // number of simulated clients
	Distribution         string  // distribution
	LinearizabilityCheck bool    // run linearizability checker at the end of benchmark

	// conflict distribution
	Conflicts int // percentage of conflicting keys
	Min       int // min key

	// normal distribution
	Mu    float64 // mu of normal distribution
	Sigma float64 // sigma of normal distribution
	Move  bool    // moving average (mu) of normal distribution
	Speed int     // moving speed in milliseconds intervals per key

	// zipfian distribution
	ZipfianS float64 // zipfian s parameter
	ZipfianV float64 // zipfian v parameter

	// exponential distribution
	Lambda float64 // rate parameter
}

type Benchmark struct {
	Bconfig
	*History
	// contains filtered or unexported fields
}

type Client interface {
	Get(Key) (Value, error)
	Put(Key, Value) error
}

type Codec interface {
	Scheme() string
	Encode(interface{})
	Decode(interface{})
}

type Command struct {
	Key       Key
	Value     Value
	ClientID  ID
	CommandID int
}

type Config struct {
	Addrs     map[ID]string `json:"address"`      // address for node communication
	HTTPAddrs map[ID]string `json:"http_address"` // address for client server communication

	Policy    string  `json:"policy"`    // leader change policy {consecutive, majority}
	Threshold float64 `json:"threshold"` // threshold for policy in WPaxos {n consecutive or time interval in ms}

	Thrifty        bool    `json:"thrifty"`          // only send messages to a quorum
	BufferSize     int     `json:"buffer_size"`      // buffer size for maps
	ChanBufferSize int     `json:"chan_buffer_size"` // buffer size for channels
	MultiVersion   bool    `json:"multiversion"`     // create multi-version database
	Benchmark      Bconfig `json:"benchmark"`        // benchmark configuration
	// contains filtered or unexported fields
}

type DB interface {
	Init() error
	Read(key int) (int, error)
	Write(key, value int) error
	Stop() error
}

type Database interface {
	Execute(Command) Value
	History(Key) []Value
	Get(Key) Value
	Put(Key, Value)
}

type HTTPClient struct {
	Addrs  map[ID]string
	HTTP   map[ID]string
	ID     ID  // client id use the same id as servers in local site
	N      int // total number of nodes
	LocalN int // number of nodes in local zone

	CID int // command id
	*http.Client
}

type History struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type ID string

type IDs []ID

type Key int

type Limiter struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type Node interface {
	Socket
	Database
	ID() ID
	Run()
	Retry(r Request)
	Forward(id ID, r Request)
	Register(m interface{}, f interface{})
}

type Policy interface {
	Hit(id ID) ID
}

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

type Read struct {
	CommandID int
	Key       Key
}

type ReadReply struct {
	CommandID int
	Value     Value
}

type Register struct {
	Client bool
	ID     ID
	Addr   string
}

type Reply struct {
	Command    Command
	Value      Value
	Properties map[string]string
	Timestamp  int64
	Err        error
}

type Request struct {
	Command    Command
	Properties map[string]string
	Timestamp  int64
	NodeID     ID // forward by node
	// contains filtered or unexported fields
}

type Socket interface {

	// Send put message to outbound queue
	Send(to ID, m interface{})

	// MulticastZone send msg to all nodes in the same site
	MulticastZone(zone int, m interface{})

	// MulticastQuorum sends msg to random number of nodes
	MulticastQuorum(quorum int, m interface{})

	// Broadcast send to all peers
	Broadcast(m interface{})

	// Recv receives a message
	Recv() interface{}

	Close()

	// Fault injection
	Drop(id ID, t int)             // drops every message send to ID last for t seconds
	Slow(id ID, d int, t int)      // delays every message send to ID for d ms and last for t seconds
	Flaky(id ID, p float64, t int) // drop message by chance p for t seconds
	Crash(t int)                   // node crash for t seconds
}

type Stat struct {
	Data   []float64
	Size   int
	Mean   float64
	Min    float64
	Max    float64
	Median float64
	P95    float64
	P99    float64
	P999   float64
}

type State interface {
	Hash() uint64
}

type StateMachine interface {
	// Execute is the state-transition function
	// returns current state value if state unchanged or previous state value
	Execute(interface{}) interface{}
}

type Transaction struct {
	Commands  []Command
	Timestamp int64
	// contains filtered or unexported fields
}

type TransactionReply struct {
	OK        bool
	Commands  []Command
	Timestamp int64
	Err       error
}

type Transport interface {
	// Scheme returns tranport scheme
	Scheme() string

	// Send sends message into t.send chan
	Send(interface{})

	// Recv waits for message from t.recv chan
	Recv() interface{}

	// Dial connects to remote server non-blocking once connected
	Dial() error

	// Listen waits for connections, non-blocking once listener starts
	Listen()

	// Close closes send channel and stops listener
	Close()
}

type Value []byte