// Initialize proxy and tribserver func initTribserver(storage string, server string, myhostport string) net.Listener { // Start proxy l, err := net.Listen("tcp", server) if err != nil { log.Fatal("listen error:", err) } pc = proxycounter.NewProxyCounter(storage, server) if pc == nil { fmt.Println("Could not start proxy") return nil } srpc := storagerpc.NewStorageRPC(pc) rpc.Register(srpc) rpc.HandleHTTP() go http.Serve(l, nil) // Start tribserver ts = tribimpl.NewTribserver(server, myhostport) if ts == nil { fmt.Println("Could not start tribserver") return nil } rpc.Register(ts) return l }
func main() { flag.Parse() if *storageMasterNodePort == "" { if *portnum == 0 { *portnum = 9009 } // Single node execution *storageMasterNodePort = fmt.Sprintf("localhost:%d", *portnum) if *numNodes == 0 { *numNodes = 1 log.Println("Self-mastering, setting nodes to 1") } } l, e := net.Listen("tcp", fmt.Sprintf(":%d", *portnum)) if e != nil { log.Fatal("listen error:", e) } _, listenport, _ := net.SplitHostPort(l.Addr().String()) log.Println("Server starting on ", listenport) *portnum, _ = strconv.Atoi(listenport) ss := storageimpl.NewStorageserver(*storageMasterNodePort, *numNodes, *portnum, uint32(*nodeID)) srpc := storagerpc.NewStorageRPC(ss) rpc.Register(srpc) rpc.HandleHTTP() http.Serve(l, nil) }
func main() { var masterPort string = "127.0.0.1:9009" var numNodes int = 2 var portnum int = 9011 var nodeID uint32 = 1 //create slave node l, e := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", portnum)) if e != nil { log.Fatal("listen error:", e) } ss := storageimpl.NewStorageserver(masterPort, numNodes, portnum, nodeID) srpc := storagerpc.NewStorageRPC(ss) rpc.Register(srpc) rpc.HandleHTTP() http.Serve(l, nil) }
// Initialize proxy and libstore func initLibstore(storage string, server string, myhostport string, flags int) net.Listener { // Start proxy l, err := net.Listen("tcp", server) if err != nil { log.Fatal("listen error:", err) } pc = proxycounter.NewProxyCounter(storage, server) if pc == nil { fmt.Println("Could not start proxy") return nil } srpc := storagerpc.NewStorageRPC(pc) rpc.Register(srpc) rpc.HandleHTTP() go http.Serve(l, nil) // Start libstore ls, err = libstore.NewLibstore(server, myhostport, flags) if ls == nil || err != nil { fmt.Println("Could not start libstore") return nil } return l }
func NewStorageserver(master string, numnodes int, portnum int, nodeid uint32) *Storageserver { //fmt.Println("called new storage server") ss := &Storageserver{} //if no nodeid is provided, choose one randomly if nodeid == 0 { reallySeedTheDamnRNG() ss.nodeid = rand.Uint32() } else { //otherwise just take the one they gave you ss.nodeid = nodeid } ss.portnum = portnum if numnodes != 0 { ss.isMaster = true } else { ss.isMaster = false } ss.nodeList = []storageproto.Node{} ss.nodeListM = make(chan int, 1) ss.nodeListM <- 1 ss.nodeMap = make(map[storageproto.Node]int) ss.nodeMapM = make(chan int, 1) ss.nodeMapM <- 1 ss.leaseMap = make(map[string]*LeaseInfo) ss.leaseMapM = make(chan int, 1) ss.leaseMapM <- 1 ss.clientLeaseMap = make(map[string]int64) ss.clientLeaseMapM = make(chan int, 1) ss.clientLeaseMapM <- 1 ss.stopRevoke = make(chan string, 1) ss.listMap = make(map[string][]string) ss.listMapM = make(chan int, 1) ss.listMapM <- 1 ss.connMap = make(map[string]*rpc.Client) ss.connMapM = make(chan int, 1) ss.connMapM <- 1 ss.valMap = make(map[string]string) ss.valMapM = make(chan int, 1) ss.valMapM <- 1 if ss.isMaster == false { ss.numNodes = 0 //connect to the master server masterClient, err := rpc.DialHTTP("tcp", master) for err != nil { //keep retrying until we can actually conenct //(Master may not have started yet) masterClient, err = rpc.DialHTTP("tcp", master) //fmt.Println("Trying to connect to master...") time.Sleep(time.Duration(3) * time.Second) } //set up args for registering ourselves info := storageproto.Node{HostPort: "localhost:" + strconv.Itoa(portnum), NodeID: ss.nodeid} args := storageproto.RegisterArgs{ServerInfo: info} reply := storageproto.RegisterReply{} for err != nil || reply.Ready != true { //call register on the master node with our info as the args. Kinda weird err = masterClient.Call("StorageRPC.Register", &args, &reply) //keep retrying until all things are registered //fmt.Println("Trying to register with master...") time.Sleep(time.Duration(3) * time.Second) } //gotta still set up some other shits //like get list of servers from reply maybe? //spec is pretty vague... <-ss.nodeListM //fmt.Println("Aquired nodeList lock NewStorageserver") ss.nodeList = reply.Servers log.Println("Successfully joined storage node cluster.") slist := "" for i := 0; i < len(ss.nodeList); i++ { res := fmt.Sprintf("{localhost:%v %v}", ss.portnum, ss.nodeid) slist += res if i < len(ss.nodeList)-1 { slist += " " } } log.Printf("Server List: [%s]", slist) ss.nodeListM <- 1 //fmt.Println("released nodeList lock NewStorageserver") //non master doesn't keep a node map cause f**k you } else { //otherwise we are the master so we have to do some other shits //maybe these are the same shits as the other dudes got to do so maybe we don't gotta bother? WHAT WHO KNOWS //set up numNodes: if numnodes == 0 { numnodes = 1 } ss.numNodes = numnodes <-ss.nodeListM //fmt.Println("aquired nodelist lock NewStorageserver") //append self to nodeList and put self in map me := storageproto.Node{HostPort: "localhost:" + strconv.Itoa(portnum), NodeID: ss.nodeid} ss.nodeList = append(ss.nodeList, me) //some shit here}) ss.nodeListM <- 1 //fmt.Println("released nodelist lock NewStorageserver") <-ss.nodeMapM //fmt.Println("aquired nodeMap lock NewStorageserver") ss.nodeMap[me] = 0 ss.nodeMapM <- 1 //fmt.Println("released nodeMap lock NewStorageserver") } ss.srpc = storagerpc.NewStorageRPC(ss) rpc.Register(ss.srpc) go ss.GarbageCollector() /*fmt.Println("started new server") fmt.Println(storageproto.Node{HostPort: "localhost:" + strconv.Itoa(portnum), NodeID: ss.nodeid}) fmt.Printf("master? %v\n", ss.isMaster) fmt.Printf("numnodes? %v\n", ss.numNodes)*/ return ss }