示例#1
0
文件: gost.go 项目: sdgdsffdsfff/gost
// If listener is non-nil, then it's used; otherwise listen on TCP using the given port.
func (s *Server) Start(port int, listener *net.TCPListener) error {
	if listener == nil {
		var err error
		ip, err := service.GetLocalIp()
		if err != nil {
			return err
		}
		addr := fmt.Sprintf("%s:%d", ip, port)
		tcpAddr, err := net.ResolveTCPAddr("tcp4", addr)
		if err != nil {
			return err
		}
		s.l.Println("Listening for debug TCP clients on", addr)
		listener, err = net.ListenTCP("tcp", tcpAddr)
		if err != nil {
			return err
		}
	}
	go func() {
		for {
			c, err := listener.AcceptTCP()
			if err != nil {
				continue
			}
			c.SetWriteDeadline(time.Now().Add(10 * time.Millisecond))
			c.SetKeepAlive(true)
			c.SetKeepAlivePeriod(tcpKeepAlivePeriod)
			c.SetNoDelay(true)
			go s.tcpClientServer(c)
		}
	}()
	return nil
}
示例#2
0
文件: main.go 项目: sdgdsffdsfff/gost
func main() {
	flag.Parse()
	conf, err := internal.ParseConf()

	if err != nil {
		log.Fatal(err)
	}
	localIp, err := service.GetLocalIp()
	if err != nil {
		log.Fatal(err)
	}
	// 注册到LOOKUP服务
	service.RegisterMoaService(&service.MoaServiceRegReq{
		ServiceUri: fmt.Sprintf("/service/prism/%s", conf.Namespace),
		HostPort:   fmt.Sprintf("%s:%d", localIp, conf.DebugPort),
		// redis是udp memcache是tcp
		Protocol: "redis",
	})
	runtime.GOMAXPROCS(runtime.NumCPU())
	log.Fatal(internal.NewServer(conf, os.Stdout).Listen(nil, nil, nil))
}
示例#3
0
文件: gost.go 项目: sdgdsffdsfff/gost
// Listen launches the various server goroutines and starts the various listeners.
// If the listener params are nil, these are constructed from the parameters in the conf. Otherwise they are
// used as-is. This makes it possible for the tests to construct listeners on an available port and pass them
// in.
func (s *Server) Listen(clientConn *net.UDPConn, forwardListener net.Listener, debugListener *net.TCPListener) error {
	go s.handleMetaStats()
	go s.flush()
	go s.aggregate()
	if s.conf.OSStats != nil {
		go s.checkOSStats()
	}
	if s.conf.Scripts != nil {
		go s.runScripts()
	}

	if s.conf.forwardingEnabled {
		s.forwardingIncoming = make(chan *Stat, incomingQueueSize)
		go s.flushForwarding()
		go s.aggregateForwarding()
	}

	errorCh := make(chan error)
	if s.conf.forwarderEnabled {
		if forwardListener == nil {
			l, err := net.Listen("tcp", s.conf.ForwarderListenAddr)
			if err != nil {
				return err
			}
			forwardListener = tcpKeepAliveListener{l.(*net.TCPListener)}
		}
		s.l.Println("Listening for forwarded gost messages on", forwardListener.Addr())
		go s.aggregateForwarded()
		go func() {
			errorCh <- s.forwardServer(forwardListener)
		}()
	}

	if err := s.Start(s.conf.DebugPort, debugListener); err != nil {
		return err
	}

	if clientConn == nil {
		ip, err := service.GetLocalIp()
		if err != nil {
			return err
		}
		udpAddr := fmt.Sprintf("%s:%d", ip, s.conf.Port)
		udp, err := net.ResolveUDPAddr("udp", udpAddr)
		if err != nil {
			return err
		}
		clientConn, err = net.ListenUDP("udp", udp)
		if err != nil {
			return err
		}
	}
	s.l.Println("Listening for UDP client requests on", clientConn.LocalAddr())
	go func() {
		errorCh <- s.clientServer(clientConn)
	}()

	// Indicate that we've started
	s.metaInc("server_start")

	return <-errorCh
}