raftkv

Documentation

Index

• Constants
• func DPrintf(format string, a ...interface{}) (n int, err error)
• type Clerk
  • func MakeClerk(servers []*labrpc.ClientEnd) *Clerk
  • func (ck *Clerk) Append(key string, value string)
  • func (ck *Clerk) Get(key string) string
  • func (ck *Clerk) Put(key string, value string)
  • func (ck *Clerk) PutAppend(key string, value string, op string)
• type ClerkTrackAction
• type Err
• type GetArgs
• type GetReply
• type KVRPCCommitItem
• type KVRPCIssueItem
• type KVRPCResp
• type KVServer
  • func StartKVServer(servers []*labrpc.ClientEnd, me int, persister *raft.Persister, ...) *KVServer
  • func (kv *KVServer) Get(args *GetArgs, reply *GetReply)
  • func (kv *KVServer) Kill()
  • func (kv *KVServer) PutAppend(args *PutAppendArgs, reply *PutAppendReply)
• type OPCode
• type Op
• type PutAppendArgs
• type PutAppendReply

Constants

const (
	OK       = "OK"
	ErrNoKey = "ErrNoKey"
)

const (
	GET    = "Get"
	PUT    = "Put"
	APPEND = "Append"
)

const ClerkTimeout = 1 * time.Second

const Debug = 0

Functions

func DPrintf

func DPrintf(format string, a ...interface{}) (n int, err error)

Types

type Clerk

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

func MakeClerk

func MakeClerk(servers []*labrpc.ClientEnd) *Clerk

func (*Clerk) Append

func (ck *Clerk) Append(key string, value string)

func (*Clerk) Get

func (ck *Clerk) Get(key string) string

func (*Clerk) Put

func (ck *Clerk) Put(key string, value string)

func (*Clerk) PutAppend

func (ck *Clerk) PutAppend(key string, value string, op string)

shared by Put and Append.

you can send an RPC with code like this: ok := ck.servers[i].Call("KVServer.PutAppend", &args, &reply)

the types of args and reply (including whether they are pointers) must match the declared types of the RPC handler function's arguments. and reply must be passed as a pointer.

type ClerkTrackAction

type ClerkTrackAction int

const (
	ClerkOK ClerkTrackAction
	ClerkIgnore
	ClerkRetry
)

type Err

type Err string

type GetArgs

type GetArgs struct {
	Key string
	// You'll have to add definitions here.
	ClerkId int64
	SeqId   int
}

type GetReply

type GetReply struct {
	WrongLeader bool
	Err         Err
	Value       string
	Leader      int
	Server      int
}

type KVRPCCommitItem

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

type KVRPCIssueItem

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

type KVRPCResp

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

type KVServer

type KVServer struct {
	DB         map[string]string
	ClerkTrack map[int64]int
	// contains filtered or unexported fields
}

func StartKVServer

func StartKVServer(servers []*labrpc.ClientEnd, me int, persister *raft.Persister, maxraftstate int) *KVServer

servers[] contains the ports of the set of servers that will cooperate via Raft to form the fault-tolerant key/value service. me is the index of the current server in servers[]. the k/v server should store snapshots through the underlying Raft implementation, which should call persister.SaveStateAndSnapshot() to atomically save the Raft state along with the snapshot. the k/v server should snapshot when Raft's saved state exceeds maxraftstate bytes, in order to allow Raft to garbage-collect its log. if maxraftstate is -1, you don't need to snapshot. StartKVServer() must return quickly, so it should start goroutines for any long-running work.

func (*KVServer) Get

func (kv *KVServer) Get(args *GetArgs, reply *GetReply)

func (*KVServer) Kill

func (kv *KVServer) Kill()

the tester calls Kill() when a KVServer instance won't be needed again. you are not required to do anything in Kill(), but it might be convenient to (for example) turn off debug output from this instance.

func (*KVServer) PutAppend

func (kv *KVServer) PutAppend(args *PutAppendArgs, reply *PutAppendReply)

type OPCode

type OPCode string

type Op

type Op struct {
	// Your definitions here.
	// Field names must start with capital letters,
	// otherwise RPC will break.
	OpCode   OPCode
	ServerId int
	ClerkId  int64
	SeqId    int
	Key      string
	Value    string
}

type PutAppendArgs

type PutAppendArgs struct {
	Key   string
	Value string
	Op    string // "Put" or "Append"
	// You'll have to add definitions here.
	// Field names must start with capital letters,
	// otherwise RPC will break.
	ClerkId int64
	SeqId   int
}

Put or Append

type PutAppendReply

type PutAppendReply struct {
	WrongLeader bool
	Err         Err
	Leader      int
	Server      int
}