shardkv

package
v0.0.0-...-1bd0170 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 14, 2016 License: MIT Imports: 17 Imported by: 0

Documentation

Index

Constants

View Source
const (
	OK            = "OK"
	ErrNoKey      = "ErrNoKey"
	ErrWrongGroup = "ErrWrongGroup"
	TimeOut       = "TimeOut"
	Error         = "Error"
	Get           = "Get"
	Put           = "Put"
	Append        = "Append"
	Transfer      = "Transfer"
	ReConfig      = "ReConfig"
	NotReady      = "NotReady"
)
View Source
const Debug = 0

Variables

This section is empty.

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(masters []*labrpc.ClientEnd, make_end func(string) *labrpc.ClientEnd) *Clerk

the tester calls MakeClerk.

masters[] is needed to call shardmaster.MakeClerk().

make_end(servername) turns a server name from a Config.Groups[gid][i] into a labrpc.ClientEnd on which you can send RPCs.

func (*Clerk) Append

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

func (*Clerk) Get

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

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 will have to modify this function.

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 will have to modify this function.

type Err

type Err string

type GetArgs

type GetArgs struct {
	Key string
	// You'll have to add definitions here.
	Cid int64
	Seq int64
}

type GetReply

type GetReply struct {
	WrongLeader bool
	Err         Err
	Value       string
}

type Op

type Op struct {
	// Your definitions here.
	// Field names must start with capital letters,
	// otherwise RPC will break.
	Action string
	Args   interface{}
}

type OpReply

type OpReply struct {
	Action string
	Args   interface{}
	Reply  interface{}
}

type PutAppendArgs

type PutAppendArgs struct {
	// You'll have to add definitions here.
	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.
	Cid int64
	Seq int64
}

Put or Append

type PutAppendReply

type PutAppendReply struct {
	WrongLeader bool
	Err         Err
}

type ReConfigArgs

type ReConfigArgs struct {
	// You'll have to add definitions here.
	Kvs            [shardmaster.NShards]map[string]string
	ClientRequests map[int64]int64
	NewConfig      shardmaster.Config
}

type ReConfigReply

type ReConfigReply struct {
	Err Err
}

type ShardKV

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

func StartServer

func StartServer(servers []*labrpc.ClientEnd, me int, persister *raft.Persister, maxraftstate int, gid int, masters []*labrpc.ClientEnd, make_end func(string) *labrpc.ClientEnd) *ShardKV

servers[] contains the ports of the servers in this group.

me is the index of the current server in servers[].

the k/v server should store snapshots with persister.SaveSnapshot(), and Raft should save its state (including log) with persister.SaveRaftState().

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.

gid is this group's GID, for interacting with the shardmaster.

pass masters[] to shardmaster.MakeClerk() so you can send RPCs to the shardmaster.

make_end(servername) turns a server name from a Config.Groups[gid][i] into a labrpc.ClientEnd on which you can send RPCs. You'll need this to send RPCs to other groups.

look at client.go for examples of how to use masters[] and make_end() to send RPCs to the group owning a specific shard.

StartServer() must return quickly, so it should start goroutines for any long-running work.

func (*ShardKV) FetchShards

func (kv *ShardKV) FetchShards(args *TransferShardArgs, reply *TransferShardReply)

func (*ShardKV) Get

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

func (*ShardKV) Kill

func (kv *ShardKV) Kill()

the tester calls Kill() when a ShardKV 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 (*ShardKV) PutAppend

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

func (*ShardKV) ReConfig

func (kv *ShardKV) ReConfig(args *ReConfigArgs, reply *ReConfigReply)

type TransferShardArgs

type TransferShardArgs struct {
	// You'll have to add definitions here.
	Shards    []int
	ConfigNum int
}

type TransferShardReply

type TransferShardReply struct {
	Err            Err
	Transferred    [shardmaster.NShards]map[string]string
	ClientRequests map[int64]int64
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL