Documentation ¶
Index ¶
- Constants
- type Clerk
- type ClerkMetaData
- type Err
- type GetArgs
- type GetReply
- type KVServer
- type LockManagerClient
- func (lm *LockManagerClient) GetLockedKeySet() []string
- func (lm *LockManagerClient) Init()
- func (lm *LockManagerClient) IsLocked(key string) bool
- func (lm *LockManagerClient) Lock(key string, issuedTime time.Time)
- func (lm *LockManagerClient) LockExpired(key string) bool
- func (lm *LockManagerClient) LockRevoked(key string) bool
- func (lm *LockManagerClient) RenewLock(key string, issuedTime time.Time)
- func (lm *LockManagerClient) Unlock(key string)
- type LockManagerServer
- func (lm *LockManagerServer) Init()
- func (lm *LockManagerServer) IsLocked(key string) bool
- func (lm *LockManagerServer) IsLockedBy(key string, clerkID int64) bool
- func (lm *LockManagerServer) Lock(key string, clerkID int64) bool
- func (lm *LockManagerServer) RenewLock(key string, clerkID int64) bool
- func (lm *LockManagerServer) Unlock(key string)
- type Op
- type PutAppendArgs
- type PutAppendReply
- type RenewLeaseArgs
- type RenewLeaseReply
Constants ¶
const ( OK = "OK" ErrNoKey = "ErrNoKey" ErrWrongLeader = "ErrWrongLeader" ErrRejectRenew = "ErrReject" ErrDup = "ErrDup" ErrLocked = "ErrLocked" )
const Debug = true
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Clerk ¶
type Clerk struct {
// contains filtered or unexported fields
}
func (*Clerk) Get ¶
fetch the current value for a key. returns "" if the key does not exist. keeps trying forever in the face of all other errors.
you can send an RPC with code like this: ok := ck.servers[i].Call("KVServer.Get", &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.
func (*Clerk) PutAppend ¶
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 ClerkMetaData ¶
type ClerkMetaData struct {
// contains filtered or unexported fields
}
type KVServer ¶
type KVServer struct {
// 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) Kill ¶
func (kv *KVServer) Kill()
------------------------------------------------------------ the tester calls Kill() when a KVServer instance won't be needed again. for your convenience, we supply code to set rf.dead (without needing a lock), and a killed() method to test rf.dead in long-running loops. you can also add your own code to Kill(). you're not required to do anything about this, but it may be convenient (for example) to suppress debug output from a Kill()ed instance.
func (*KVServer) PutAppend ¶
func (kv *KVServer) PutAppend(args *PutAppendArgs, reply *PutAppendReply)
func (*KVServer) RenewLease ¶
func (kv *KVServer) RenewLease(args *RenewLeaseArgs, reply *RenewLeaseReply)
This op does not need to be replicated and can be immediately executed on the leader. But leader should ensure it is the newest. i.e. ReadReady
type LockManagerClient ¶
type LockManagerClient struct {
// contains filtered or unexported fields
}
Client side lock manager.
func (*LockManagerClient) GetLockedKeySet ¶
func (lm *LockManagerClient) GetLockedKeySet() []string
func (*LockManagerClient) Init ¶
func (lm *LockManagerClient) Init()
func (*LockManagerClient) IsLocked ¶
func (lm *LockManagerClient) IsLocked(key string) bool
func (*LockManagerClient) Lock ¶
func (lm *LockManagerClient) Lock(key string, issuedTime time.Time)
func (*LockManagerClient) LockExpired ¶
func (lm *LockManagerClient) LockExpired(key string) bool
func (*LockManagerClient) LockRevoked ¶
func (lm *LockManagerClient) LockRevoked(key string) bool
func (*LockManagerClient) RenewLock ¶
func (lm *LockManagerClient) RenewLock(key string, issuedTime time.Time)
func (*LockManagerClient) Unlock ¶
func (lm *LockManagerClient) Unlock(key string)
type LockManagerServer ¶
type LockManagerServer struct { LockTable map[string]int64 // locked key -> clerkID CanRenew map[string]bool }
Server side lock manger.
func (*LockManagerServer) Init ¶
func (lm *LockManagerServer) Init()
func (*LockManagerServer) IsLocked ¶
func (lm *LockManagerServer) IsLocked(key string) bool
Query the lock table to see if the key is locked by anyone. It will disable the renewing of the lock, because when called, there is another clerk who wants to lock the key.
func (*LockManagerServer) IsLockedBy ¶
func (lm *LockManagerServer) IsLockedBy(key string, clerkID int64) bool
Query the lock table to see if the key is locked by the clerk. It will NOT disable the renewing of the lock.
func (*LockManagerServer) RenewLock ¶
func (lm *LockManagerServer) RenewLock(key string, clerkID int64) bool
func (*LockManagerServer) Unlock ¶
func (lm *LockManagerServer) Unlock(key string)
type PutAppendArgs ¶
type PutAppendArgs struct { KVMap map[string]string // You'll have to add definitions here. // Field names must start with capital letters, // otherwise RPC will break. ClerkID int64 SeqNo int }
Put or Append
type PutAppendReply ¶
type PutAppendReply struct {
Err Err
}