func iNewLspServer(port int, params *LspParams) (*LspServer, error) { srv := new(LspServer) srv.nextId = 1 if params == nil { // Insert default parameters params = &LspParams{5, 2000} } srv.params = params hostport := fmt.Sprintf(":%v", port) addr, err := lspnet.ResolveUDPAddr("udp", hostport) if lsplog.CheckReport(1, err) { return nil, err } srv.udpConn, err = lspnet.ListenUDP("udp", addr) if lsplog.CheckReport(1, err) { return nil, err } srv.readBuf = NewBuf() // Need enough room to recycle close messages srv.appReadChan = make(LspMessageChan, 1) srv.appWriteChan = make(LspMessageChan) srv.netInChan = make(networkChan) srv.epochChan = make(chan int) srv.connById = make(map[uint16]*lspConn) srv.connByAddr = make(map[string]*lspConn) srv.closeReplyChan = make(chan error, 1) srv.closeAllReplyChan = make(chan error, 1) srv.writeReplyChan = make(chan error, 1) go srv.serverLoop() go srv.udpReader() go epochTrigger(srv.params.EpochMilliseconds, srv.epochChan, &srv.stopGlobalNetworkFlag) return srv, nil }
func iNewLspClient(hostport string, params *LspParams) (*LspClient, error) { client := new(LspClient) client.WBchan = make(chan *LspMessage, 1) client.Echan = make(chan int, 1) client.EchanBack = make(chan int, 1) client.Rchan = make(chan int) client.Wchan = make(chan int, 1) client.CloseChan = make(chan int, 1) client.CloseChanEpoch = make(chan int, 1) client.CloseNetworkChan = make(chan int, 1) client.RBchan = make(chan *LspMessage) client.eventHandClosedChan = make(chan int, 1) client.Nchan = make(chan *LspMessage, 1) client.established = make(chan int) client.writeEnded = make(chan int, 1) client.writeList = new(list.List) client.readList = new(list.List) client.errChan = make(chan error, 1) client.exitEpochHandler = make(chan int, 1) client.continueEpochHandler = make(chan int, 1) client.AckWrite = true client.allowWrite = true client.sn = 1 client.rcvn = 1 client.id = 0 client.NbWrite = 0 if params == nil { client.params = &LspParams{5, 2000} } else { client.params = params } addr, errResolve := lspnet.ResolveUDPAddr("udp", hostport) if errResolve != nil { return nil, errResolve } connexion, errDial := lspnet.DialUDP("udp", nil, addr) if errDial != nil { return nil, errDial } client.conn = connexion client.running = true msg, _ := buildMSG(MsgCONNECT, 0, 0, nil) client.writeList.PushBack(msg) client.NbWrite++ client.lastWrite = msg client.Wchan <- 1 client.epochCount = 0 client.eventHandClosed = false go NetworkHandlerClient(client) go EpochHandlerClient(client) go EventHandlerClient(client) <-client.established return client, nil }
func NewLoadBalancer(port int, monitorhostport string) *LoadBalancer { lb := new(LoadBalancer) lsplog.Vlogf(1, "[NewLoadBalancer] Dialing master... %v", monitorhostport) // connexion to monitor // server to communicate with workers lb.server, _ = lsp12.NewLspServer(port+10, &lsp12.LspParams{5, 2000}) lb.monitor, _ = rpc.DialHTTP("tcp", monitorhostport) name, _ := os.Hostname() addrs, _ := net.LookupHost(name) lb.myAddress = addrs[0] args := &commproto.RegisterLoadBalancerArgs{fmt.Sprintf("%s:%v", addrs[0], port)} var reply commproto.RegisterLoadBalancerReply lb.monitor.Call("MonitorRPC.RegisterLoadBalancer", args, &reply) lsplog.Vlogf(1, "[NewLoadBalancer] Completed registration %s %+v", reply.Buddy, reply.LoadBalancersHostPort) lb.buddy = reply.Buddy lb.loadBalancers = reply.LoadBalancersHostPort // get workers lb.workers = reply.Workers lb.numberOfWorkers = len(lb.workers) lsplog.Vlogf(2, "[LoadBalancer] Establishing conn to workers") // establish RPC connexion load balancers lb.workersRPC = make(map[string]*rpc.Client) for i := 0; i < len(lb.workers); i++ { lb.workersRPC[lb.workers[i]], _ = rpc.DialHTTP("tcp", lb.workers[i]) } lsplog.Vlogf(2, "[LoadBalancer] Establishing conn to LB") // establish RPC connexion with workers //numLbs := len(lb.loadBalancers) lb.LbsRPC = make(map[string]*rpc.Client) //for i := 0; i < numLbs; i ++ { //lb.LbsRPC[lb.loadBalancers[i]], _ = rpc.DialHTTP("tcp", lb.loadBalancers[i]) //} lsplog.Vlogf(2, "[LoadBalancer] Established connections") lb.clientDict = make(map[uint16]*commproto.ClientS) lb.replicatedInformation = make(map[string]int) //lsplog.Vlogf(1, "[LoadBalancer] Received buddy: %s loadBalancers: %s", reply.Buddy, lb.loadBalancers) // connexion to switch addr, errResolve := lspnet.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port)) if errResolve != nil { return nil } connexion, errDial := lspnet.ListenUDP("udp", addr) if errDial != nil { return nil } lb.connSwitch = connexion lsplog.Vlogf(1, "[LoadBalancer] Received buddy: %s loadBalancers: %s", reply.Buddy, lb.loadBalancers) go lb.runLoadBalancer() go lb.buddyHeartbeat() return lb }
func (m *Monitor) startSwitch() { for i := 0; i < m.numberOfWorkers+m.numberOfLoadBalancers; i++ { <-m.informSwitch } addrs := make([]*lspnet.UDPAddr, m.numberOfLoadBalancers) i := 0 for e := m.loadBalancers.Front(); e != nil; e = e.Next() { lb := e.Value.(*commproto.LoadBalancerInformation) addrs[i], _ = lspnet.ResolveUDPAddr("udp", lb.Hostport) i++ } cli, _ := rpc.DialHTTP("tcp", m.switchHostPort) args := &commproto.RegisterArgs{NumLB: m.loadBalancers.Len(), Addrs: addrs} cli.Call("SwitchRPC.RegisterLoadBalancers", args, nil) }
func NewSwitch(port int) *Switch { sw := new(Switch) sw.connId = 1 sw.registered = make(chan bool, 1) addr, errResolve := lspnet.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port)) if errResolve != nil { return nil } connexion, errListen := lspnet.ListenUDP("udp", addr) if errListen != nil { return nil } sw.srv = connexion go runServer(sw) return sw }
func iNewLspServer(port int, params *LspParams) (*LspServer, error) { server := new(LspServer) server.ClientDict = make(map[uint16]*iClient) server.Wchan = make(chan int, 1) server.WBchan = make(chan *LspMessage, 1) server.Nchan = make(chan *LspMessage, 1) server.Echan = make(chan int, 1) server.EchanBack = make(chan int, 1) server.CloseChan = make(chan int, 1) server.CloseChanEpoch = make(chan int, 1) server.CloseNetworkChan = make(chan int, 1) server.eventHandClosedChan = make(chan int, 1) server.CloseConnChan = make(chan uint16, 1) server.Rchan = make(chan int) server.RBchan = make(chan *LspMessage) server.Addrchan = make(chan *lspnet.UDPAddr, 1) server.writeEnded = make(chan int, 1) server.errChan = make(chan error, 1) server.exitEpochHandler = make(chan int, 1) server.continueEpochHandler = make(chan int, 1) server.connId = 1 server.NbWrite = 0 server.readList = new(list.List) if params == nil { server.params = &LspParams{5, 2000} } else { server.params = params } addr, errResolve := lspnet.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port)) if errResolve != nil { return nil, errResolve } connexion, errListen := lspnet.ListenUDP("udp", addr) if errListen != nil { return nil, errListen } server.conn = connexion server.running = true server.epochCount = 0 server.eventHandClosed = false go NetworkHandlerServer(server) go EventHandlerServer(server) go EpochHandlerServer(server) return server, nil }
func iNewLspClient(hostport string, params *LspParams) (*LspClient, error) { cli := new(LspClient) if params == nil { // Insert default parameters params = &LspParams{5, 2000} } cli.params = params addr, err := lspnet.ResolveUDPAddr("udp", hostport) if lsplog.CheckReport(1, err) { return nil, err } cli.lspConn = newConn(addr, 0, 0) // Client's first received message will be data message. cli.lspConn.nextRecvSeqNum = NextSeqNum(0) cli.udpConn, err = lspnet.DialUDP("udp", nil, addr) if lsplog.CheckReport(1, err) { return nil, err } // Need enough room to recycle close messages at end cli.appReadChan = make(LspMessageChan, 2) cli.readBuf = NewBuf() cli.appWriteChan = make(LspMessageChan, 1) cli.netInChan = make(LspMessageChan, 1) cli.epochChan = make(chan int) cli.closeReplyChan = make(chan error, 2) cli.writeReplyChan = make(chan error, 2) go cli.clientLoop() go cli.udpReader() go epochTrigger(cli.params.EpochMilliseconds, cli.epochChan, &cli.lspConn.stopNetworkFlag) // Send connection request to server nm := GenConnectMessage() cli.udpWrite(nm) cli.lspConn.pendingMsg = nm cli.lspConn.nextSendSeqNum = NextSeqNum(0) cm := <-cli.appReadChan if cm.Type == MsgCONNECT { return cli, nil } return nil, lsplog.MakeErr("Connection failed") }