// // 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)) }