//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
// Your initialization code here.
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
func RegisterServices(server *rpc.Server) {
for _, s := range services {
//TODO : the service type is as of now int, need to find out a
// way how to get the type of an object
server.Register(s)
}
}
func (c *ConsumerServer) RegistFunctions(server *rpc.Server) error {
err := server.Register(new(Call))
if err != nil {
log.Printf("Consumer regist object failed! err:%s \n", err)
return err
}
return nil
}
// Create a new DryMartini object with its own kademlia and RPC server
func NewDryMartini(listenStr string, keylen int) *DryMartini {
var err error
var s *rpc.Server
var dm *DryMartini
dm = new(DryMartini)
dm.EasyNewFlowIndex = 0
//Initialize key pair
dm.KeyPair, err = rsa.GenerateKey(rand.Reader, keylen)
if err != nil {
dbg.Printf("Failed to generate key! %s", true, err)
panic(1)
}
//Initialize flow struct
dm.Bartender = make(map[UUID]MartiniPick)
dm.Momento = make(map[UUID][]FlowIDSymmKeyPair)
dm.MapFlowIndexToFlowID = make(map[int]FlowInfo)
var host net.IP
var port uint16
host, port, err = kademlia.AddrStrToHostPort(listenStr)
//Initialize our Kademlia
//portStr := strconv.FormatUint(uint64(port), 10)
//var rpcPathStr string = kademlia.RpcPath+portStr
var rpcPathStr = "junk"
dbg.Printf("making new Kademlia with listenStr:%s, rpcPath\n", Verbose, listenStr, rpcPathStr)
dm.KademliaInst, s = kademlia.NewKademlia(listenStr, &rpcPathStr)
kademlia.BucketsAsArray(dm.KademliaInst)
//myMartiniContact <- ip, port, public key
dm.myMartiniContact.NodeIP = host.String()
dm.myMartiniContact.NodePort = port
dm.myMartiniContact.PubKey = dm.KeyPair.PublicKey.N.String()
dm.myMartiniContact.PubExp = dm.KeyPair.PublicKey.E
dbg.Printf("NewDryMartini: making new Kademlia with NodeIP: %s. NodePort:%d\n", Verbose, dm.myMartiniContact.NodeIP, dm.myMartiniContact.NodePort)
/*
if Verbose {
dbg.Printf("NodeIP: %s\n", dm.myMartiniContact.NodeIP)
dbg.Printf("NodePort: %d\n", dm.myMartiniContact.NodePort)
dbg.Printf("PubKey: %s\n", dm.myMartiniContact.PubKey)
dbg.Printf("PubExp: %d\n", dm.myMartiniContact.PubKey)
}*/
//register
err = s.Register(dm)
if err != nil {
dbg.Printf("Failed to register Drymartini! %s", true, err)
panic(1)
}
return dm
}
func (p *ProducerServer) RegistFunctions(server *rpc.Server) error {
err := server.Register(new(Call))
if err != nil {
log.Printf("register function failed!err:%s \n", err)
return err
}
err = server.Register(new(PMSync))
if err != nil {
log.Printf("regist PMSync failed! err:%s \n", err)
return err
}
return nil
}
// NewServerCodec returns a new rpc.ServerCodec using JSON-RPC 2.0 on conn,
// which will use srv to execute batch requests.
//
// If srv is nil then rpc.DefaultServer will be used.
func NewServerCodec(conn io.ReadWriteCloser, srv *rpc.Server) rpc.ServerCodec {
if srv == nil {
srv = rpc.DefaultServer
}
srv.Register(JSONRPC2{})
return &serverCodec{
dec: json.NewDecoder(conn),
enc: json.NewEncoder(conn),
c: conn,
srv: srv,
pending: make(map[uint64]*json.RawMessage),
}
}
// NewPolicyMgr Creates a new policy manager
func NewPolicyAgent(agent *OfnetAgent, rpcServ *rpc.Server) *PolicyAgent {
policyAgent := new(PolicyAgent)
// initialize
policyAgent.agent = agent
policyAgent.Rules = make(map[string]*PolicyRule)
policyAgent.DstGrpFlow = make(map[string]*ofctrl.Flow)
// Register for Master add/remove events
rpcServ.Register(policyAgent)
// done
return policyAgent
}
// Create a new vrouter instance
func NewVrouter(agent *OfnetAgent, rpcServ *rpc.Server) *Vrouter {
vrouter := new(Vrouter)
// Keep a reference to the agent
vrouter.agent = agent
// Create a route table and my router mac
vrouter.routeTable = make(map[string]*OfnetRoute)
vrouter.flowDb = make(map[string]*ofctrl.Flow)
vrouter.portVlanFlowDb = make(map[uint32]*ofctrl.Flow)
vrouter.myRouterMac, _ = net.ParseMAC("00:00:11:11:11:11")
// Register for Route rpc callbacks
rpcServ.Register(vrouter)
return vrouter
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.stateMap = make(map[int]State)
px.maxCanDisregard = -1
px.lastDoneSignalled = -1
flag.Parse()
px.me = me
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
glog.Fatalf("listen error: ", e)
}
px.l = l
// create a thread to accept RPC connections
go func() {
for px.isdead() == false {
conn, err := px.l.Accept()
if err == nil && px.isdead() == false {
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
} else if err == nil {
conn.Close()
}
if err != nil && px.isdead() == false {
//////fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
func StartDNS(servers []string, rpcs *rpc.Server) *DNSserver {
// call gob.Register on structures you want
// Go's RPC library to marshall/unmarshall.
gob.Register(DNSserver{})
gob.Register(GetServerArgs{})
gob.Register(GetServerReply{})
dns := new(DNSserver)
dns.servers = servers
dns.address = portDNS()
if rpcs != nil {
// caller will create socket &c
rpcs.Register(dns)
} else {
rpcs = rpc.NewServer()
rpcs.Register(dns)
os.Remove(dns.address)
l, e := net.Listen("unix", dns.address)
if e != nil {
log.Fatal("listen error: ", e)
}
dns.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for {
conn, err := dns.l.Accept()
if err == nil {
go rpcs.ServeConn(conn)
}
if err != nil {
fmt.Printf("DNSerror: %v\n", err.Error())
}
}
}()
}
return dns
}
func (s *Server) handleConnection(conn net.Conn) {
// We create a new server each time so that we can have access to the
// underlying connection. The standard rpc package does not give us access
// to the calling connection :/
var server *rpc.Server = rpc.NewServer()
// Get a free service from the pool.
var service *Discovery
select {
case service = <-s.servicePool:
// Success
default:
service = newDiscoveryService(s)
}
// Set up the service variables.
service.init(conn, atomic.AddInt32(&s.nextConnId, 1))
// If debugging is enabled, log all rpc traffic.
var rwc io.ReadWriteCloser = conn
if *debug {
rwc = &debugInput{conn}
}
// Set up the rpc service and start serving the connection.
server.Register(service)
server.ServeCodec(jsonrpc.NewServerCodec(rwc))
// Connection has disconnected. Remove any registered services.
s.removeAll(service)
// Reset the service state.
service.init(nil, -1)
select {
case s.servicePool <- service:
// Success
default:
// Buffer is full
}
}
// Create a new vxlan instance
func NewVxlan(agent *OfnetAgent, rpcServ *rpc.Server) *Vxlan {
vxlan := new(Vxlan)
// Keep a reference to the agent
vxlan.agent = agent
// init DBs
vxlan.macRouteDb = make(map[string]*MacRoute)
vxlan.vlanDb = make(map[uint16]*Vlan)
vxlan.macFlowDb = make(map[string]*ofctrl.Flow)
vxlan.portVlanFlowDb = make(map[uint32]*ofctrl.Flow)
log.Infof("Registering vxlan RPC calls")
// Register for Route rpc callbacks
err := rpcServ.Register(vxlan)
if err != nil {
log.Fatalf("Error registering vxlan RPC")
}
return vxlan
}
func Server() {
var err error
var l net.Listener
l, err = net.Listen("tcp", ":1234")
if err != nil {
log.Fatal("listen error:", err)
}
defer l.Close()
var s *rpc.Server
s = rpc.NewServer()
s.Register(new(Arith))
for {
var err error
var c net.Conn
c, err = l.Accept()
log.Println(c.RemoteAddr())
if err != nil {
log.Fatal("listen error:", err)
}
go s.ServeCodec(jsonrpc.NewServerCodec(c))
}
}
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
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server, network bool, tag string) *Paxos {
px := &Paxos{}
// Read memory options
px.persistent = persistent
px.recovery = recovery
px.dbUseCompression = dbUseCompression
px.dbUseCache = dbUseCache
px.dbCacheSize = dbCacheSize
px.writeToMemory = writeToMemory
// Network stuff
px.peers = peers
px.me = me
px.network = network
px.reachable = make([]bool, len(px.peers))
for i := range px.peers {
px.reachable[i] = true
}
px.deaf = false
// Paxos state
px.instances = make(map[int]Proposal)
px.leader = make(map[int]int)
px.proposed = make(map[int]bool)
px.maxInstance = -1
px.done = make(map[int]int)
for i := 0; i < len(px.peers); i++ {
px.done[i] = -1
}
px.doneChannels = make(map[int]chan bool)
// Persistence stuff
waitChan := make(chan int)
go func() {
waitChan <- 1
px.startup(tag)
}()
<-waitChan
if rpcs != nil {
// caller will create socket &c
if !printRPCerrors {
disableLog()
rpcs.Register(px)
enableLog()
} else {
rpcs.Register(px)
}
} else {
rpcs = rpc.NewServer()
if !printRPCerrors {
disableLog()
rpcs.Register(px)
enableLog()
} else {
rpcs.Register(px)
}
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
if px.network {
l, e := net.Listen("tcp", ":"+strconv.Itoa(startport))
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
} else {
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
}
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.deaf || (px.unreliable && (rand.Int63()%1000) < 100) {
// discard the request.
conn.Close()
} else if px.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
if !px.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)
}
} else {
//respond to imaginary port?
c1 := conn.(*net.TCPConn)
f, _ := c1.File()
err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
}
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
fmt.Println("Peer Number: ", len(peers))
px.fates = make(map[int]Fate)
px.seens = make(map[int]int)
px.accepts = make(map[int]int)
px.values = make(map[int]interface{})
px.dones = make([]int, len(peers))
px.highest = -1
px.maxSeen = px.me
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.isdead() == false {
conn, err := px.l.Accept()
if err == nil && px.isdead() == false {
if px.isunreliable() && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
} else {
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.isdead() == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
func setupPortRPC(rs *rpc.Server) error {
rs.Register(SASLDAuth{})
return nil
}
func FinishMake(px *Paxos, rpcs *rpc.Server) *Paxos {
px.instances = make(map[int]*Instance)
px.multi_locks = make(map[int]*sync.Mutex)
px.majority = len(px.peers) / 2
px.prevDone = -1
px.PingTimes = make(map[int]time.Time)
for index, _ := range px.peers {
px.PingTimes[index] = time.Now()
}
if px.me+1 == len(px.peers) {
px.Leader = true
} else {
px.Leader = false
}
px.NewLeader = false
px.MajorityMax = -1
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(px.peers[px.me]) // only needed for "unix"
l, e := net.Listen("unix", px.peers[px.me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", px.me, err.Error())
}
}
}()
}
go px.MultiPaxos()
return px
}
func rpcSetup(rs *rpc.Server) error {
log.Print("Ready!")
rs.Register(RPC{})
return nil
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
// Your initialization code here.
px.acceptorInstances = make(map[int]*PxAcceptorInstance)
px.proposerInstances = make(map[int]*PxProposerInstance)
px.peerDones = minimumSetInit(len(px.peers))
px.maxSeq = -1
px.maxKnownSeq = -1
px.minSeq = 0
// Start garbage collection thread
go func() {
for px.isdead() == false {
px.garbageCollect()
time.Sleep(100 * time.Millisecond)
}
}()
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
log.Printf("listen: %v\n", peers[me])
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.isdead() == false {
conn, err := px.l.Accept()
if err == nil && px.isdead() == false {
if px.isunreliable() && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
} else {
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.isdead() == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
var formatter = logging.MustStringFormatter(`%{color} %{shortfunc} : %{message} %{color:reset}`)
logging.SetLevel(logging.CRITICAL, "paxos")
logging.SetFormatter(formatter)
px := &Paxos{}
px.peers = peers
px.me = me
px.done = make([]int, len(px.peers))
for i := range px.done {
px.done[i] = -1
}
// Your initialization code here.
px.instances = make(map[int]*PaxosInstance)
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Debug("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.isdead() == false {
conn, err := px.l.Accept()
if err == nil && px.isdead() == false {
if px.isunreliable() && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
} else {
atomic.AddInt32(&px.rpcCount, 1)
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.isdead() == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
fmt.Printf("peers: %v\n", px.peers)
px.UID = GetMD5Hash(peers[me])
os.Mkdir("logs", 0700)
px.logPath = "logs/peer-" + px.UID
os.Mkdir(px.logPath, 0700)
px.DeleteBarrier = (1 << 31) - 1
px.initializeEncoder()
// Your initialization code here.
px.instances = make(map[int]Instance)
px.maxProposalNs = make(map[int]int64)
px.maxAcceptNs = make(map[int]int64)
px.maxAcceptVs = make(map[int]interface{})
px.minSeqNums = make([]int, len(peers), len(peers))
px.maxAcceptPeerIds = make(map[int]int)
for z := 0; z < len(peers); z++ {
px.minSeqNums[z] = -1
}
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen(Network, peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
// Close decision log file
px.decisionFile.Close()
}()
}
return px
}
//
// 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, port_meteor string, rpcs *rpc.Server) *MMDatabase {
// call gob.Register on structures you want
// Go's RPC library to marshall/unmarshall.
gob.Register(Message{})
gob.Register(GetCoordListArgs{})
gob.Register(GetCoordListReply{})
gob.Register(ReplicaPutArgs{})
gob.Register(ReplicaPutReply{})
gob.Register(CoordPutArgs{})
gob.Register(CoordPutReply{})
gob.Register(GetArgs{})
gob.Register(GetReply{})
db := new(MMDatabase)
db.dead = false
db.me = me
db.port_meteor = port_meteor
db.servers = servers
db.nServers = len(servers)
db.nReplicas = 3
db.handoffMessages = make([]*Message, 0)
if rpcs != nil {
// caller will create socket &c
rpcs.Register(db)
} else {
rpcs = rpc.NewServer()
rpcs.Register(db)
os.Remove(servers[me])
l, e := net.Listen("unix", servers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
db.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for db.dead == false {
conn, err := db.l.Accept()
if err == nil && db.dead == false {
if db.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if db.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)
}
db.rpcCount++
go rpcs.ServeConn(conn)
} else {
db.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && db.dead == false {
fmt.Printf("MMDatabase(%v) accept: %v\n", me, err.Error())
}
}
}()
}
go db.runHandoffLoop()
return db
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func Make(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
// Your initialization code here.
px.instances = make(map[int]InstanceStatus) // Status of each sequence number
px.doneResponses = make(map[string]int) // Responses from each peer from Done method
px.minSequence = 0 // Minimum stored sequence
px.maxSequence = 0 // Maximum stored sequence
// Not sure exactly what gob.Register does, so not sure if these are needed...
gob.Register(Proposal{})
gob.Register(Decision{})
gob.Register(ForgetSequence{})
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
// change "unix" to "tcp" to use over a network.
os.Remove(peers[me]) // only needed for "unix"
l, e := net.Listen("unix", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// please do not change any of the following code,
// or do anything to subvert it.
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.unreliable && (rand.Int63()%1000) < 100 {
// discard the request.
conn.Close()
} else if px.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)
}
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
}
return px
}
//
// the application wants to create a paxos peer.
// the ports of all the paxos peers (including this one)
// are in peers[]. this servers port is peers[me].
//
func NewPaxos(peers []string, me int, rpcs *rpc.Server) *Paxos {
px := &Paxos{}
px.peers = peers
px.me = me
px.instances = make(map[int]*InstanceState)
px.localMin = -1
px.globalMin = -1
// init the min heap
px.minHeap = MakeIntHeap()
px.minChan = make(chan N, len(px.peers))
if rpcs != nil {
// caller will create socket &c
rpcs.Register(px)
} else {
rpcs = rpc.NewServer()
rpcs.Register(px)
// prepare to receive connections from clients.
l, e := net.Listen("tcp", peers[me])
if e != nil {
log.Fatal("listen error: ", e)
}
px.l = l
// create a thread to accept RPC connections
go func() {
for px.dead == false {
conn, err := px.l.Accept()
if err == nil && px.dead == false {
if px.unreliable && (rand.Int63()%1000) < 100 {
// simply ignores the request
conn.Close()
} else if px.unreliable && (rand.Int63()%1000) < 200 {
// process the request but force discard of reply.
// close the write of the connection
c1 := conn.(*net.TCPConn)
err := c1.CloseWrite()
// equivalent to below syscall:
// f, _ := c1.File()
// err := syscall.Shutdown(int(f.Fd()), syscall.SHUT_WR)
if err != nil {
fmt.Printf("shutdown: %v\n", err)
}
// serve the rpc
px.rpcCount++
go rpcs.ServeConn(conn)
} else {
px.rpcCount++
go rpcs.ServeConn(conn)
}
} else if err == nil {
conn.Close()
}
if err != nil && px.dead == false {
fmt.Printf("Paxos(%v) accept: %v\n", me, err.Error())
}
}
}()
// launch background GC thread
go px.gc(px.minChan)
}
return px
}
func ApiRegistry(s *rpc.Server) {
s.Register(new(handlers.Job))
}
