Exemple #1
0
// StartHTTP start listen http.
func StartHTTP() {
	// external
	httpServeMux := http.NewServeMux()
	// 1.0
	httpServeMux.HandleFunc("/public/send", SendPublicMsg)
	httpServeMux.HandleFunc("/sub/send", SendSubMsg)
	httpServeMux.HandleFunc("/get/connectserver", GetAvalConnSrv)
	httpServeMux.HandleFunc("/get/offlinemsg", GetOfflineMsgs)

	for _, bind := range Conf.HttpBind {
		fmt.Printf("start http listen addr:\"%s\"", bind)
		go httpListen(httpServeMux, bind)
	}

	//开启send srv rpc
	client, err := rpc.DialHTTP("tcp", Conf.Ms)
	if err != nil {
		panic(err.Error())
		fmt.Printf("web start rpc failed, connect %s failed\n", Conf.Ms)
		return
	}
	msClient = client

	conn, err := redis.Dial("tcp", Conf.Redis)
	if err != nil {
		panic(err.Error())
	}
	redClient = conn

	zkConn = common.ZkConnect(Conf.ZooKeeper)
}
Exemple #2
0
func StartMs() {

	ms := NewMS()
	rpc.Register(ms)
	rpc.HandleHTTP()

	go func() {
		err := http.ListenAndServe(Conf.TcpBind, nil)
		if err != nil {
			fmt.Printf("ms rpc error: %s\n", err.Error())
		}
	}()

	//服务器初始化完成以后,开启zookeeper
	zkConn = common.ZkConnect(Conf.ZooKeeper)
	common.ZkCreateRoot(zkConn, Conf.ZkRoot)
	//为当前ms服务器创建一个节点,加入到ms集群中
	path := Conf.ZkRoot + "/" + Conf.TcpBind
	common.ZkCreateTempNode(zkConn, path)
	go func() {
		exist, _, watch, err := zkConn.ExistsW(path)
		if err != nil {
			//发生错误,当前节点退出
			fmt.Printf("%s occur error\n", path)
			common.KillSelf()
		}

		if !exist {
			//节点不存在了
			fmt.Printf("%s not exist\n", path)
			common.KillSelf()
		}

		event := <-watch
		fmt.Printf("%s receiver a event %v\n", path, event)
	}()
}
Exemple #3
0
func StartPushSrv() {
	ps := NewPushSrv()
	rpc.Register(ps)
	rpc.HandleHTTP()

	go func() {
		err := http.ListenAndServe(Conf.TcpBind, nil)
		if err != nil {
			fmt.Printf("pushsrv rpc error: %s\n", err.Error())
		}
	}()

	//服务器初始化完成以后,开启zookeeper
	zkConn = common.ZkConnect(Conf.ZooKeeper)
	common.ZkCreateRoot(zkConn, Conf.ZkRoot)
	//为当前push服务器创建一个节点,加入到push集群中
	path := Conf.ZkRoot + "/" + Conf.TcpBind
	common.ZkCreateTempNode(zkConn, path)
	go func() {
		exist, _, watch, err := zkConn.ExistsW(path)
		if err != nil {
			//发生错误,当前节点退出
			fmt.Printf("%s occur error\n", path)
			common.KillSelf()
		}

		if !exist {
			//节点不存在了
			fmt.Printf("%s not exist\n", path)
			common.KillSelf()
		}

		event := <-watch
		fmt.Printf("%s receiver a event %v\n", path, event)
	}()

	//初始化conn srv可用列表
	connZkConn := common.ZkConnect(Conf.ConnZooKeeper)
	children := common.ZkGetChildren(connZkConn, Conf.ConnZkRoot)
	if children != nil {
		//更新可用客户端列表
		for _, host := range children {
			avalConnClient[host] = initRpcClient(host)
		}
	}

	//开一个goroute处理conn srv服务器节点变化
	go func() {
		for {
			_, _, events, err := connZkConn.ChildrenW(Conf.ConnZkRoot)
			if err != nil {
				time.Sleep(time.Second * 1)
				continue
			}

			evt := <-events
			if evt.Type == zk.EventNodeChildrenChanged {
				//conn节点有变化,更新conn列表
				isStopSecond = true
				time.Sleep(time.Second * 1)

				for host, rcpCli := range avalConnClient {
					rcpCli.Close()
					delete(avalConnClient, host)
				}

				children := common.ZkGetChildren(connZkConn, Conf.ConnZkRoot)
				for _, host := range children {
					avalConnClient[host] = initRpcClient(host)
				}

				isStopSecond = false
			}
		}
	}()

	//可以开始处理消息
	isStopSecond = false
}
Exemple #4
0
//服务器启动
func (self *Server) Start() {
	listener, err := net.Listen("tcp", Conf.TcpBind)
	self.listener = listener
	if err != nil {
		fmt.Printf("server %s listen failed", Conf.TcpBind)
		return
	}

	fmt.Printf("server %s start\n", Conf.TcpBind)

	go func() {
		fmt.Printf("begin to accept connects\n")

		for {
			conn, err := self.listener.Accept()

			if err != nil {
				fmt.Printf("server accept error : \"%v\"", err)
				return
			}

			fmt.Printf("new client connect: \"%v\"", conn)
			self.pending <- conn
			fmt.Printf("new client into pending\n")
		}
	}()

	//服务器初始化完成以后,开启zookeeper
	zkConn = common.ZkConnect(Conf.ZooKeeper)
	common.ZkCreateRoot(zkConn, Conf.ZkRoot)
	//为当前服务器创建一个节点,加入到集群中
	path := Conf.ZkRoot + "/" + Conf.RcpBind
	common.ZkCreateTempNode(zkConn, path)
	go func() {
		for {
			exist, _, watch, err := zkConn.ExistsW(path)
			if err != nil {
				//发生错误,当前节点退出
				common.KillSelf()
				return
			}

			if !exist {
				//节点不存在了
				common.KillSelf()
				return
			}

			event := <-watch
			fmt.Printf("%s receiver a event %v\n", path, event)
		}
	}()

	//获取存储子节点列表
	var size int
	children := common.ZkGetChildren(zkConn, Conf.MsZkRoot)
	if children != nil {
		//开启新的客户端
		for _, host := range children {
			msClients[size] = common.InitRpcClient(host)
			size++
		}

		msLen = size
		isMsStop = false
		fmt.Printf("ms len %d\n", msLen)
	}

	//开一个goroute处理ms服务器节点变化
	go func() {
		for {
			_, _, events, err := zkConn.ChildrenW(Conf.MsZkRoot)
			if err != nil {
				time.Sleep(time.Second * 1)
				continue
			}

			evt := <-events
			if evt.Type == zk.EventNodeChildrenChanged {
				// ms节点有变化,更新ms列表
				// 停止当前的ms处理
				isMsStop = true
				time.Sleep(time.Second * 1) //暂停一秒,让在处理中的ms处理完成

				size = 0
				//关闭原先ms客户端
				for _, mc := range msClients {
					if mc != nil {
						mc.Close()
						msClients[size] = nil
					}
					size++
				}

				//获取子节点列表
				children := common.ZkGetChildren(zkConn, Conf.MsZkRoot)
				if children == nil {
					fmt.Printf("no ms rpc servers\n")
					continue
				}

				size = 0
				//开启新的客户端
				for _, host := range children {
					msClients[size] = common.InitRpcClient(host)
					size++
				}

				msLen = size
				isMsStop = false
				fmt.Printf("ms len %d\n", msLen)
			}
		}
	}()
}
Exemple #5
0
func StartSendSrv() {
	isMsStop = true
	isPsStop = true
	msLen = 0
	psLen = 0

	rand.Seed(time.Now().UnixNano())

	conn, err := redis.Dial("tcp", Conf.Redis)
	if err != nil {
		fmt.Printf("tcp redis %v\n", err.Error())
		return
	}
	redClient = conn

	msgGet, msgPut = common.MakeMessageRecycler()

	msgPushPool = make(chan *common.Message, 4096)
	msgStorePool = make(chan *common.Message)

	go func() {
		msIdx := 0
		for {
			//ms列表有变化
			if isMsStop || msLen == 0 {
				time.Sleep(time.Second * 1)
				continue
			}
			msIdx = rand.Intn(msLen)
			m, err := redis.String(redClient.Do("RPOP", "msg_queue_0"))
			if m == "" {
				time.Sleep(time.Second)
				continue
			}
			if err == nil {
				var msg common.Message
				err = json.Unmarshal([]byte(m), &msg)
				if err == nil {
					HandleServerMsg(&msg, msClients[msIdx])
				}
			}
		}
	}()

	go func() {
		var success bool
		psIdx := 0
		for {
			//ms列表有变化
			if isPsStop || psLen == 0 {
				time.Sleep(time.Second * 1)
				continue
			}

			if m := <-msgPushPool; m != nil {
				psIdx = rand.Intn(psLen)
				err := pushSrvClients[psIdx].Call("PushSrv.SendMsg", *m, &success)
				if err != nil || !success {
					fmt.Printf("call push srv send message failed")
				}
			}
		}
	}()

	go func() {
		var success bool
		msIdx := 0
		for {
			//ms列表有变化
			if isMsStop || msLen == 0 {
				time.Sleep(time.Second * 1)
				continue
			}

			select {
			case m := <-msgStorePool:
				//MS落地存储
				msIdx = rand.Intn(msLen)
				err := msClients[msIdx].Call("MS.SaveMessage", *m, &success)
				if err != nil || !success {
					fmt.Printf("send server call MS SaveMessage failed")
				}
				msgPut <- m
			}
		}
	}()

	//服务器初始化完成,启动zookeeper
	zkConn = common.ZkConnect(Conf.ZooKeeper)
	size := 0
	//获取子节点列表
	children := common.ZkGetChildren(zkConn, Conf.MsZkRoot)
	if children != nil {
		//开启新的客户端
		for _, host := range children {
			msClients[size] = initRpcClient(host)
			size++
		}

		msLen = size
		isMsStop = false
		fmt.Printf("ms len %d\n", msLen)
	}
	//获取push子节点列表
	psSize := 0
	psChildren := common.ZkGetChildren(zkConn, Conf.PsZkRoot)
	if psChildren != nil {
		//开启新的客户端
		for _, psHost := range psChildren {
			pushSrvClients[psSize] = initRpcClient(psHost)
			psSize++
		}

		psLen = psSize
		isPsStop = false
		fmt.Printf("ps len %d\n", psLen)
	}

	//开一个goroute处理ms服务器节点变化
	go func() {
		for {
			_, _, events, err := zkConn.ChildrenW(Conf.MsZkRoot)
			if err != nil {
				time.Sleep(time.Second * 1)
				continue
			}

			evt := <-events
			if evt.Type == zk.EventNodeChildrenChanged {
				// ms节点有变化,更新ms列表
				// 停止当前的ms处理
				isMsStop = true
				time.Sleep(time.Second * 1) //暂停一秒,让在处理中的ms处理完成

				size = 0
				//关闭原先ms客户端
				for _, mc := range msClients {
					if mc != nil {
						mc.Close()
						msClients[size] = nil
					}
					size++
				}

				//获取子节点列表
				children := common.ZkGetChildren(zkConn, Conf.MsZkRoot)
				if children == nil {
					fmt.Printf("no ms rpc servers\n")
					continue
				}

				size = 0
				//开启新的客户端
				for _, host := range children {
					msClients[size] = initRpcClient(host)
					size++
				}

				msLen = size
				isMsStop = false
				fmt.Printf("ms len %d\n", msLen)
			}
		}
	}()

	//开一个goroute处理push服务器节点变化
	go func() {
		for {
			_, _, events, err := zkConn.ChildrenW(Conf.PsZkRoot)
			if err != nil {
				time.Sleep(time.Second * 1)
				continue
			}

			evt := <-events
			if evt.Type == zk.EventNodeChildrenChanged {
				// push节点有变化,更新push列表
				// 停止当前的push处理
				isPsStop = true
				time.Sleep(time.Second * 1) //暂停一秒,让在处理中的push处理完成

				psSize = 0
				//关闭原先push客户端
				for _, psc := range pushSrvClients {
					if psc != nil {
						psc.Close()
						pushSrvClients[psSize] = nil
					}
					psSize++
				}

				//获取子节点列表
				children := common.ZkGetChildren(zkConn, Conf.PsZkRoot)
				if children == nil {
					fmt.Printf("no ps rpc servers\n")
					continue
				}

				psSize = 0
				//开启新的客户端
				for _, host := range children {
					pushSrvClients[psSize] = initRpcClient(host)
					psSize++
				}

				psLen = psSize
				isPsStop = false
				fmt.Printf("ps len %d\n", psLen)
			}
		}
	}()
}