//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *KVPaxos {
// call gob.Register on structures you want
// Go's RPC library to marshall/unmarshall.
gob.Register(Op{})
kv := new(KVPaxos)
kv.me = me
// initialization
kv.kvData = make(map[string]string)
kv.preReply = make(map[string]*Op)
kv.seqChan = make(map[int]chan *Op)
kv.maxInstanceID = -1
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("KVPaxos(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go kv.updateStatus()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *KVPaxos {
// Go's RPC library to marshall/unmarshall.
gob.Register(Op{})
kv := new(KVPaxos)
kv.me = me
kv.seenMap = make(map[int64]bool)
kv.kvData = make(map[string]string)
kv.toprocess = 1
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
glog.Fatal("listen error: ", e)
}
kv.l = l
go func() {
for kv.isdead() == false {
conn, err := kv.l.Accept()
if err == nil && kv.isdead() == false {
go rpcs.ServeConn(conn)
} else if err == nil {
conn.Close()
}
if err != nil && kv.isdead() == false {
glog.Warningln("KVPaxos(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *KVPaxos {
// this call is all that's needed to persuade
// Go's RPC library to marshall/unmarshall
// struct Op.
gob.Register(Op{})
kv := new(KVPaxos)
kv.me = me
// Your initialization code here.
kv.mydb = map[string]string{}
kv.history = map[int64]string{}
kv.DoneInst = 0
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("KVPaxos(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
return kv
}
func StartServer(servers []string, me int) *ShardMaster {
gob.Register(Op{})
sm := new(ShardMaster)
path_parts := strings.Split(servers[me], "/")
sm.db_path = db_path + path_parts[len(path_parts)-1]
os.Remove(sm.db_path)
sm.db = dbaccess.GetDatabase(sm.db_path)
// Put my index
sm.db.PutInt(METADATA, "me", me)
sm.me = me
// Enter peers
sm.db.PutStringList(METADATA, "servers", servers)
first_conf := new(Config)
first_conf.Groups = map[int64][]string{}
sm.DBPutConfig(0, first_conf)
sm.db.PutInt(METADATA, "num_configs", 1)
rpcs := rpc.NewServer()
rpcs.Register(sm)
sm.px = paxos.Make(servers, me, rpcs)
FinishStartServer(sm, servers, me, rpcs)
return sm
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant shardmaster service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *ShardMaster {
gob.Register(Op{})
sm := new(ShardMaster)
sm.me = me
sm.configs = make([]Config, 1)
sm.configs[0].Groups = map[int64][]string{}
//your initialization
sm.cfgnum = 0
rpcs := rpc.NewServer()
rpcs.Register(sm)
sm.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
sm.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for sm.dead == false {
conn, err := sm.l.Accept()
if err == nil && sm.dead == false {
if sm.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if sm.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && sm.dead == false {
fmt.Printf("ShardMaster(%v) accept: %v\n", me, err.Error())
sm.Kill()
}
}
}()
return sm
}
func NewKVPaxosMap(peers []string, me int) *KVPaxosMap {
m := &KVPaxosMap{}
m.lock = sync.Mutex{}
m.px = paxos.Make(peers, me, nil)
m.done = 0
m.data = make(map[string]string)
m.dead = false
return m
}
func NewEPServer(pxpeers []string, me int, sio *socketio.Server) *EPServer {
gob.Register(PxLogEntry{})
es := &EPServer{}
es.sio = sio
es.px = paxos.Make(pxpeers, me, nil)
es.skts = make(map[string]string)
es.pads = make(map[string]*PadManager)
es.commitPoint = 0
return es
}
func StartWhanauPaxos(servers []string, me int, uid string,
rpcs *rpc.Server) *WhanauPaxos {
wp := new(WhanauPaxos)
if rpcs != nil {
// caller will create socket &c
rpcs.Register(wp)
} else {
rpcs := rpc.NewServer()
rpcs.Register(wp)
}
newservers := make([]string, len(servers))
for i, _ := range servers {
newservers[i] = port(uid+"-wp", i)
}
wp.handledRequests = make(map[int64]interface{})
wp.px = paxos.Make(newservers, me, nil)
wp.db = make(map[KeyType]TrueValueType)
wp.pending_writes = make(map[PendingInsertsKey]string)
wp.currSeq = 0
wp.currView = 0
wp.me = me
wp.myaddr = servers[me]
wp.uid = uid
gob.Register(Op{})
gob.Register(PaxosGetArgs{})
gob.Register(PaxosPutArgs{})
gob.Register(PaxosGetReply{})
gob.Register(PaxosPutReply{})
gob.Register(PaxosPendingInsertsArgs{})
gob.Register(PaxosPendingInsertsReply{})
return wp
}
func MakeServer(servers []string, me int, dc DeveloperCoord, numTaskReplicas int, seed int64, socktype string) *Coordinator {
gob.Register(Op{})
gob.Register(map[string]interface{}{})
gob.Register([]interface{}{})
co := new(Coordinator)
co.socktype = socktype
co.me = me
co.dc = dc
co.currentView = View{0, false, nil, map[TaskID]TaskParams{}, map[TaskID][]ClientID{}, map[TaskID][]ClientID{}, map[TaskID]TaskInfo{}, map[ClientID]string{}}
co.initialized = false
co.leaderID = 0
co.leaderNum = 0
co.currentSeq = -1
co.lastQueries = map[ClientID]int{}
co.lastLeaderElection = time.Now()
co.seed = seed
co.numTaskReplicas = numTaskReplicas
co.unassignedTasks = list.New()
co.activeTasks = map[ClientID]map[TaskID]bool{}
co.availableClients = map[ClientID]int{}
co.killedTasks = map[TaskID]bool{}
co.finishedTasks = map[TaskID]bool{}
co.isFinished = false
rpcs := rpc.NewServer()
rpcs.Register(co)
co.px = paxos.Make(servers, me, rpcs, socktype)
// TODO: change this implementation for TCP sockets when necessary
os.Remove(servers[me])
l, e := net.Listen(co.socktype, servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
co.l = l
// Code to listen and serve requests
go func() {
for !co.dead {
conn, err := co.l.Accept()
if err == nil && !co.dead {
if co.unreliable && (rand.Int63()%1000) < 100 {
// discard the request
conn.Close()
} else if co.unreliable && (rand.Int63()%1000) < 200 {
// process request but discard reply
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && !co.dead {
fmt.Printf("Coordinator(%v) accept: %v\n", me, err.Error())
co.Kill()
}
}
}()
return co
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
gob.Register(GetArgs{})
gob.Register(PutArgs{})
gob.Register(ReConfigStartArgs{})
gob.Register(ReConfigEndArgs{})
gob.Register(ReceiveShardArgs{})
gob.Register(SentShardArgs{})
gob.Register(NoopArgs{})
gob.Register(KVPair{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
// Your initialization code here.
// Don't call Join().
kv.config_prior = shardmaster.Config{} // initial prior Config
kv.config_prior.Groups = map[int64][]string{} // initialize map
kv.config_now = shardmaster.Config{} // initial prior Config
kv.config_now.Groups = map[int64][]string{} // initialize map
kv.shards = make([]bool, shardmaster.NShards)
kv.transition_to = -1
kv.storage = map[string]string{} // key/value data storage
kv.cache = map[string]Reply{} // "client_id:request_id" -> reply cache
kv.operation_number = -1 // first agreement number will be 0
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
DPrintf("%d.%d starting", me, gid)
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
kv.contOK = make(chan bool)
// Your initialization code here.
// Don't call Join().
kv.config = &shardmaster.Config{}
kv.shards = &shards{shards: make([]map[int]map[string]string,
shardmaster.NShards), latest: 0}
for i, _ := range kv.shards.shards {
kv.shards.shards[i] = make(map[int]map[string]string)
}
kv.states = &clientStates{states: make([]map[int]map[string]*Op,
shardmaster.NShards), latest: 0}
for i, _ := range kv.states.states {
kv.states.states[i] = make(map[int]map[string]*Op)
}
kv.outstanding = make(map[int]chan *Op)
kv.highestApplied = -1
kv.count = 0
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
go kv.getStatus()
return kv
}
func main() {
var npaxos = flag.Int("npaxos", 3, "number of paxos instances")
var ngroups = flag.Int("ngroups", 3, "number of shard groups")
var nmasters = flag.Int("nmasters", 3, "number of shardmasters per shard group")
var nreplicas = flag.Int("nreplicas", 3, "number of kvshard replicas per group")
var clean = flag.Bool("clean", false, "clean the db")
flag.Parse()
args := flag.Args()
if len(args) < 1 {
fmt.Printf("Not enough arguments, must specify program type:\n" +
" paxos|shardmaster|shardkv\n")
os.Exit(1)
}
switch args[0] {
case "paxos":
fmt.Println("Attempting to start paxos server...")
if *clean {
cleanDB("paxos")
}
peers := test.GetPaxos(*npaxos)
me := whoami(peers)
if me == -1 {
fmt.Println("Host didn't find own IP in peer list! Exiting!")
os.Exit(1)
}
paxos.Make(peers, me, nil, network, "somedbtag")
fmt.Println("peers: ", peers)
fmt.Println("me: ", me)
fmt.Printf("Started paxos server.\n")
case "shardmaster":
fmt.Println("Attempting to start shardmaster server...")
if *clean {
cleanDB("shardmaster")
}
peers, _ := test.GetShardmasters(*nmasters, *ngroups)
me := whoami(peers)
if me == -1 {
fmt.Println("Host didn't find own IP in peer list! Exiting!")
os.Exit(1)
}
shardmaster.StartServer(peers, me, network)
fmt.Println("peers: ", peers)
fmt.Println("me: ", me)
fmt.Printf("Started shardmaster.\n")
case "shardkv":
fmt.Println("------------------------------------------")
fmt.Println(getIP(), "attempting to start shardkv server...")
//---------Default Shardmaster Servers------------
//group 100: 10.0.0.101
//group 101: 10.0.0.102
//group 102: 10.0.0.103
//-----------Default ShardKV Servers--------------
//group 100: 10.0.0.104, 10.0.0.105, 10.0.0.106
//group 101: 10.0.0.107, 10.0.0.108, 10.0.0.109
//group 102: 10.0.0.110, 10.0.0.111, 10.0.0.112
metapeers, masters, _ := test.GetShardkvs(*nreplicas, *nmasters, *ngroups)
fmt.Printf("peers: %v\n", metapeers)
me := whoami(masters)
if me != -1 {
fmt.Println("Starting shardmaster instead.")
if *clean {
cleanDB("shardmaster")
}
shardmaster.StartServer(masters, me, network)
fmt.Printf("peers: %v\n", masters)
fmt.Printf("me: %d\n", me)
fmt.Println("Success!")
select {}
}
var gid int64
peers := make([]string, *ngroups)
for i, v := range metapeers {
peers = v
me = whoami(v)
gid = int64(100 + i)
if me != -1 {
break
}
}
if me == -1 {
fmt.Printf("Exiting! Host didn't find own IP %s in peer list: %v! "+
"or masters: %v\n",
getIP(), metapeers, masters)
os.Exit(1)
}
if *clean {
cleanDB("shardkv")
}
fmt.Println("masters:", masters)
fmt.Printf("peers: %v\n", peers)
fmt.Printf("me: %d, gid :%d\n", me, gid)
shardkv.StartServer(gid, masters, peers, me, network)
default:
fmt.Printf("Invalid program type, choose one:" +
" paxos|shardmaster|shardkv")
os.Exit(1)
}
select {}
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
// Your initialization code here.
// Don't call Join().
kv.reply_signal = make(map[OpID]chan bool)
kv.store = make(map[int]map[string]string)
kv.last_reply = make(map[int]ReplyRecord)
kv.shard_record = make(map[int]map[int]map[string]string)
kv.reply_record = make(map[int]map[int]ReplyRecord)
kv.record_level = -1
kv.min_confignums = make(map[int64]int)
kv.InitNewConfig(kv.sm.Query(-1))
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
kv.config_to_seq = make(map[int]int)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
go kv.LogWalker()
go kv.ManageConfigMins()
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
time.Sleep(time.Duration(kv.me*10) * time.Millisecond)
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant shardmaster service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *ShardMaster {
gob.Register(Op{})
// RPC library needs to know how to marshall/unmarshall the different types of Args
gob.Register(JoinArgs{})
gob.Register(LeaveArgs{})
gob.Register(MoveArgs{})
gob.Register(QueryArgs{})
gob.Register(NoopArgs{})
sm := new(ShardMaster)
sm.me = me
sm.configs = make([]Config, 1) // initially just a 0th Config
sm.configs[0].Groups = map[int64][]string{} // initialize map
sm.operation_number = -1 // first agreement number is 0
rpcs := rpc.NewServer()
rpcs.Register(sm)
sm.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
sm.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for sm.dead == false {
conn, err := sm.l.Accept()
if err == nil && sm.dead == false {
if sm.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if sm.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && sm.dead == false {
fmt.Printf("ShardMaster(%v) accept: %v\n", me, err.Error())
sm.Kill()
}
}
}()
return sm
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64,
shardmasters []string,
servers []string, me int,
messagebrokers []string) *ShardKV {
gob.Register(Op{})
gob.Register(PutArgs{})
gob.Register(GetArgs{})
gob.Register(SubscribeArgs{})
gob.Register(ReconfigArgs{})
gob.Register(TransferArgs{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
kv.mb = messagebroker.MakeNotifier(messagebrokers)
kv.config = kv.sm.Query(0)
kv.table = make(map[string]*Entry)
kv.tableCache = make(map[int]map[string]*Entry)
kv.reqs = make(map[string]*Result)
kv.reqsCache = make(map[int]map[string]*Result)
kv.lastAppliedSeq = -1
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.Kill()
}
}
}()
go func() {
for !kv.dead {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
go kv.logSync()
return kv
}
func StartServer(servers []string, me int) *MBServer {
gob.Register(Op{})
gob.Register(PublishArgs{})
gob.Register(NotifyPutArgs{})
gob.Register(NotifySubscribeArgs{})
mb := new(MBServer)
mb.me = me
mb.reqs = make(map[string]map[int64]Err)
mb.buffer = make(map[string]map[int64]*PublishArgs)
mb.next = make(map[string]int64)
mb.subscribers = make(map[string]*Subscriber)
mb.lastAppliedSeq = -1
rpcs := rpc.NewServer()
rpcs.Register(mb)
mb.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
mb.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for mb.dead == false {
conn, err := mb.l.Accept()
if err == nil && mb.dead == false {
if mb.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if mb.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && mb.dead == false {
fmt.Printf("MBServer(%v) accept: %v\n", me, err.Error())
mb.Kill()
}
}
}()
go mb.logSync()
return mb
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
// dir is the directory name under which this
// replica should store all its files.
// each replica is passed a different directory.
// restart is false the very first time this server
// is started, and true to indicate a re-start
// after a crash or after a crash with disk loss.
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int, dir string, restart bool) *DisKV {
kv := new(DisKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
kv.dir = dir
// Your initialization code here.
// Don't call Join().
// log.SetOutput(ioutil.Discard)
gob.Register(Op{})
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
// log.SetOutput(os.Stdout)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.isdead() == false {
conn, err := kv.l.Accept()
if err == nil && kv.isdead() == false {
if kv.isunreliable() && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.isunreliable() && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.isdead() == false {
fmt.Printf("DisKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.isdead() == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
gob.Register(&ConfigBid{})
gob.Register(&StartHandoff{})
gob.Register(&EndHandoff{})
gob.Register(&ShardData{})
gob.Register(&PutArgs{})
gob.Register(&GetArgs{})
gob.Register(&GetShardArgs{})
gob.Register(&PingArgs{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
for i := range kv.dataForShard {
kv.dataForShard[i] = &ShardData{
Id: i,
Data: make(map[string]string),
}
}
kv.cond = sync.NewCond(&kv.dataForShard[shardmaster.NShards].mu)
kv.dataForShard[shardmaster.NShards].active = true
kv.dataForShard[shardmaster.NShards].Num = -1
kv.requests = make(map[int64]*RequestState)
kv.subscribe = make(chan ExecuteRequest)
kv.commitRequest = make(chan Op)
kv.commitResponse = make(chan int)
kv.ping = make(chan PingArgs, 100)
go kv.commitRequests()
go kv.executeStateMachine()
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *KVPaxos {
// call gob.Register on structures you want
// Go's RPC library to marshall/unmarshall.
gob.Register(Op{})
kv := new(KVPaxos)
kv.me = me
// Your initialization code here.
kv.contiguous = -1
kv.storage = make(map[string]string)
kv.xactions = make(map[string]xaction)
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
// go func() { // background process to always update the state of the KVPaxos to be correct about decisions.
// for !kv.dead {
// kv.mu.Lock()
// // fmt.Printf("tick....")
// kv.px.Start(kv.contiguous+1, Op{Action:NOOP})
// kv.mu.Unlock()
// time.Sleep(NOOP_TICK)
// }
// }()
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("KVPaxos(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
// dir is the directory name under which this
// replica should store all its files.
// each replica is passed a different directory.
// restart is false the very first time this server
// is started, and true to indicate a re-start
// after a crash or after a crash with disk loss.
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int, dir string, restart bool) *DisKV {
kv := new(DisKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
kv.dir = dir
// Your initialization code here.
// Don't call Join().
kv.config = shardmaster.Config{Num: -1}
kv.data = make(map[string]string)
kv.seen = make(map[string]int)
kv.replyOfErr = make(map[string]Err)
kv.replyOfValue = make(map[string]string)
kv.seq = -1
// log.SetOutput(ioutil.Discard)
gob.Register(Op{})
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
// log.SetOutput(os.Stdout)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// reload the data from disk if restart
if restart {
// fmt.Printf("Restart !")
for i := 0; i < shardmaster.NShards; i++ {
kv.data = kv.fileReadShard(i, kv.data)
}
var data PersistentData
err := kv.readPersistentData(&data)
if err == nil {
kv.seen = data.Seen
kv.replyOfErr = data.ReplyOfErr
kv.replyOfValue = data.ReplyOfValue
kv.seq = data.Seq
}
// fmt.Printf("Restart!\n")
// fmt.Printf("%v\n", err)
// fmt.Printf("%v\n", data.Seen)
// fmt.Printf("%v\n", data.ReplyOfErr)
// fmt.Printf("%v\n", data.ReplyOfValue)
// fmt.Printf("%v\n", data.Seq)
// kv.seq = data.Seq
// kv.px = &data.Px
}
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.isdead() == false {
conn, err := kv.l.Accept()
if err == nil && kv.isdead() == false {
if kv.isunreliable() && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.isunreliable() && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.isdead() == false {
fmt.Printf("DisKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.isdead() == false {
kv.tick()
time.Sleep(50 * time.Millisecond)
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
gob.Register(ServerState{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
// Your initialization code here.
// Don't call Join().
kv.localLog = make(map[int]Op)
kv.Counter = 1
kv.horizon = 0
kv.configNum = -1
kv.max = 0
// setup cell storage
id := int(rand.Int31n(1000000)) // TODO: change to be recoverable?
kv.storage = MakeStorage(id, 1000000000, "127.0.0.1:27017")
kv.storage.Clear()
kv.current = ServerState{make(map[int]map[string]string), make(map[string]ClientReply)}
kv.results = make(map[string]ClientReply)
kv.configs = make(map[int]shardmaster.Config)
kv.configs[-1] = shardmaster.Config{}
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
kv.uid = strconv.FormatInt(nrand(), 10)
// Logging
kv.logFilename = fmt.Sprintf("logs/paxos_log_%d_%d.log", kv.me, kv.gid)
var err error
kv.logFile, err = os.OpenFile(kv.logFilename, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
kv.enc = gob.NewEncoder(kv.logFile)
// go kv.logBackground()
os.Remove(servers[me])
l, e := net.Listen(Network, servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
DPrintf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
DPrintf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.Kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant shardmaster service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int, network bool) *ShardMaster {
gob.Register(Op{})
var err error
if Log == 1 {
//set up logging
os.Remove("shardmaster.log")
logfile, err = os.OpenFile("shardmaster.log", os.O_RDWR|os.O_CREATE|os.O_APPEND|os.O_SYNC, 0666)
if err != nil {
log.Fatalf("error opening file: %v", err)
} else {
log.Printf("opened shardmaster.log for logging")
}
enableLog()
}
DPrintf("Shardamaster %s server started with peers", servers[me], servers)
sm := new(ShardMaster)
// Read memory options
sm.persistent = persistent
sm.recovery = recovery
sm.dbUseCompression = dbUseCompression
sm.dbUseCache = dbUseCache
sm.dbCacheSize = dbCacheSize
sm.writeToMemory = writeToMemory
// Network stuff
sm.me = me
sm.network = network
// Shardmaster state
sm.processedSeq = -1
sm.maxConfig = 0
sm.configs = make(map[int]*Config)
sm.configs[0] = &Config{}
sm.configs[0].Groups = map[int64][]string{}
// Persistence stuff
waitChan := make(chan int)
go func() {
waitChan <- 1
sm.startup(servers)
}()
<-waitChan
rpcs := rpc.NewServer()
if !printRPCerrors {
disableLog()
rpcs.Register(sm)
//fmt.Println("registering")
enableLog()
} else {
rpcs.Register(sm)
}
sm.px = paxos.Make(servers, me, rpcs, network, "shardmaster")
if sm.network {
port := servers[me][len(servers[me])-5 : len(servers[me])]
fmt.Printf("I am peers[%d] = %s, about to listen on port %s\n", me,
servers[me], port)
l, e := net.Listen("tcp", port)
if e != nil {
log.Fatal("listen error: ", e)
}
sm.l = l
} else {
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
sm.l = l
}
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for sm.dead == false {
conn, err := sm.l.Accept()
if err == nil && sm.dead == false {
if sm.deaf || (sm.unreliable && (rand.Int63()%1000) < 100) {
// discard the request.
conn.Close()
} else if sm.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
if !sm.network {
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && sm.dead == false {
fmt.Printf("ShardMaster(%v) accept: %v\n", me, err.Error())
sm.Kill()
}
}
}()
return sm
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.uid = strconv.Itoa(me) + string("-") + strconv.FormatInt(gid, 10)
kv.sm = shardmaster.MakeClerk(shardmasters)
kv.servers = servers
// Your initialization code here.
kv.logged = make(map[int64]bool)
kv.values = make(map[string]string)
// Don't call Join().
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
gob.Register(ClientResponse{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
// Your initialization code here.
// Don't call Join().
DPrintf("\n\n%v-%v: My servers are %v\n\nMy shardmasters are %v\n\n", kv.gid, kv.me, servers, shardmasters)
toPrint = make(map[int64]string)
kv.kvDatabase = make(map[int]map[string]string)
kv.currentConfig = shardmaster.Config{}
kv.myShards = make(map[int]bool)
kv.receivedShards = make(map[int]*ShardArgs)
kv.maxSequenceCommitted = -1
kv.seenXID = make(map[int]map[int64]bool)
kv.clientResponses = make(map[int]map[int64]*ClientResponse)
kv.replyChannels = make(map[int64]chan Op)
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// Start a shardkv server.
// gid is the ID of the server's replica group.
// shardmasters[] contains the ports of the
// servers that implement the shardmaster.
// servers[] contains the ports of the servers
// in this replica group.
// Me is the index of this server in servers[].
//
func StartServer(gid int64, shardmasters []string,
servers []string, me int) *ShardKV {
gob.Register(Op{})
gob.Register(shardmaster.Config{})
gob.Register(Xaction{})
gob.Register(GetArgs{})
gob.Register(PutArgs{})
gob.Register(GimmeDataArgs{})
gob.Register(GimmeDataReply{})
kv := new(ShardKV)
kv.me = me
kv.gid = gid
kv.sm = shardmaster.MakeClerk(shardmasters)
// Your initialization code here.
// Don't call Join().
kv.now = kv.sm.Query(0)
kv.next = kv.sm.Query(0)
kv.contiguous = -1
kv.storage = make(map[string]string)
kv.xactions = make(map[string]Xaction)
kv.versions = make(map[int]Snapshot)
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("ShardKV(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
go func() {
for kv.dead == false {
kv.tick()
time.Sleep(250 * time.Millisecond)
}
}()
return kv
}
//
// servers[] contains the ports of the set of
// servers that will cooperate via Paxos to
// form the fault-tolerant key/value service.
// me is the index of the current server in servers[].
//
func StartServer(servers []string, me int) *KVPaxos {
// this call is all that's needed to persuade
// Go's RPC library to marshall/unmarshall
// struct Op.
gob.Register(Op{})
kv := new(KVPaxos)
kv.me = me
// Your initialization code here.
kv.kvstore = KVStorage{state: map[string]string{},
operation_number: -1,
}
/* Only makes state map useable (non-nil). Maps nested inside of a state entry
like state[5] will be nil maps which need to be initialized when state[5] is
set*/
kv.kvcache = KVCache{state: make(map[int]map[int]*CacheEntry)}
rpcs := rpc.NewServer()
rpcs.Register(kv)
kv.px = paxos.Make(servers, me, rpcs)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
kv.l = l
// please do not change any of the following code,
// or do anything to subvert it.
go func() {
for kv.dead == false {
conn, err := kv.l.Accept()
if err == nil && kv.dead == false {
if kv.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if kv.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
c1 := conn.(*net.UnixConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
go rpcs.ServeConn(conn)
} else {
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && kv.dead == false {
fmt.Printf("KVPaxos(%v) accept: %v\n", me, err.Error())
kv.kill()
}
}
}()
return kv
}
