func main() {

	l4g.LoadConfiguration("log4g.xml")

	ivr.InitIVRServer(8084)
	// ivr.InitDB("tcp(172.168.2.107:3306)", "root", "root01", "ivr")
}

func main() {
	flag.Parse()
	if err := InitConfig(); err != nil {
		panic(err)
	}
	runtime.GOMAXPROCS(Conf.MaxProc)
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	log.Info("logic[%s] start", Ver)
	perf.Init(Conf.PprofAddrs)
	// router rpc
	if err := InitRouter(); err != nil {
		log.Warn("router rpc current can't connect, retry")
	}
	MergeRoomCount()
	go SyncRoomCount()
	// logic rpc
	if err := InitRPC(NewDefaultAuther()); err != nil {
		panic(err)
	}
	if err := InitKafka(Conf.KafkaAddrs); err != nil {
		panic(err)
	}
	if err := InitHTTP(); err != nil {
		panic(err)
	}
	// block until a signal is received.
	InitSignal()
}

// Configure the Application
func (a *Application) Configure() error {
	log.Debug("Reading logging config file")

	log.LoadConfiguration("./loggers.xml")

	log.Debug("Reading application config file")

	file, err := ioutil.ReadFile("./config.json")
	if err != nil {
		log.Error("Error opening config file: ", err)
		panic(err)
	}

	log.Info("Config Loaded:\n\n" + string(file))

	var config Config
	err = json.Unmarshal(file, &config)
	if err != nil {
		log.Error("Error parsing config file: ", err)
		panic(err)
	}

	debug, ok := config["debug"].(bool)
	if !ok {
		debug = false
	}

	a.Config = config
	a.Debug = debug

	return nil
}

func main() {
	var err error
	// Parse cmd-line arguments
	flag.Parse()
	log.Info("web ver: \"%s\" start", ver.Version)
	if err = InitConfig(); err != nil {
		panic(err)
	}
	// Set max routine
	runtime.GOMAXPROCS(Conf.MaxProc)
	// init log
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	// init zookeeper
	zkConn, err := InitZK()
	if err != nil {
		if zkConn != nil {
			zkConn.Close()
		}
		panic(err)
	}
	// start pprof http
	perf.Init(Conf.PprofBind)
	// start http listen.
	StartHTTP()
	// process init
	if err = process.Init(Conf.User, Conf.Dir, Conf.PidFile); err != nil {
		panic(err)
	}
	// init signals, block wait signals
	signalCH := InitSignal()
	HandleSignal(signalCH)
	log.Info("web stop")
}

func TestWebManager(t *testing.T) {
	l4g.LoadConfiguration("../../config/logConfig.xml")

	configFile, readConfigFileErr := os.Open("../../config/overwall.config")
	if readConfigFileErr != nil {
		t.Fatal(readConfigFileErr)
	}
	decoder := json.NewDecoder(configFile)
	config := &Config{}
	decoder.Decode(&config)

	fmt.Printf("config info:\n%+v\n", config)

	opt := news.Option{}
	opt.SpeechFileDir = config.SpeechFileDir
	opt.SpeechCache = config.CacheSize
	opt.SentenceLen = config.OneSentenceLen
	opt.MaxGenVoiceTask = config.MaxGenVoiceTask
	opt.EasyreadUsername = config.EasyreadUsername
	opt.EasyreadPwd = config.EasyreadPwd
	opt.GenVoiceFile = true

	fmt.Printf("opt info:\n%+v\n", opt)

	newsManager := news.NewNewsManager(opt)
	webManager := NewWebManager(newsManager, "8787", "/home/noah/workspace/OverWall/config/chimes1.mp3")
	webManager.StartServer()
}

func main() {

	runtime.GOMAXPROCS(runtime.NumCPU())
	//l4g.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter("server.log", false))
	// creates a tcp listener
	l4g.LoadConfiguration("./conf/log4go.xml")
	tcpAddr, err := net.ResolveTCPAddr("tcp4", ":8989")
	checkError(err)
	listener, err := net.ListenTCP("tcp", tcpAddr)
	checkError(err)
	defer l4g.Close()
	// creates a server
	config := &gotcp.Config{
		PacketSendChanLimit:    20,
		PacketReceiveChanLimit: 20,
	}
	srv := gotcp.NewServer(config, &Callback{}, &echo.EchoProtocol{})

	// starts service
	go srv.Start(listener, time.Second)
	l4g.Debug("listening: %s", listener.Addr())
	//log.Println("listening:", listener.Addr())

	// catchs system signal
	chSig := make(chan os.Signal)
	signal.Notify(chSig, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR2) //, syscall.SIGINT, syscall.SIGTERM
	l4g.Trace("Signal: %s", <-chSig)
	//log.Println("Signal: ", <-chSig)

	// stops service
	srv.Stop()
}

func main() {
	var (
		addr     *net.UDPAddr
		listener *net.UDPConn
		err      error
	)
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	if addr, err = net.ResolveUDPAddr("udp4", Conf.Bind); err != nil {
		log.Error("net.ResolveUDPAddr(\"udp4\", \"%s\") error(%v)", Conf.Bind, err)
		return
	}

	if listener, err = net.ListenUDP("udp4", addr); err != nil {
		log.Error("net.ListenUDP(\"udp4\", \"%v\") error(%v)", addr, err)
		return
	}
	defer listener.Close()

	if Debug {
		log.Debug("start udp listen: \"%s\"", Conf.Bind)
	}

	//N core accept
	for i := 0; i < Conf.MaxProc; i++ {
		go acceptUDP(listener)
	}
	//wait
	InitSignal()
}

func loadLog4goConfig() {
	log4go.Debug("Loading configuration")
	_, err := os.Stat(logname)
	if os.IsNotExist(err) {
		return
	}
	log4go.LoadConfiguration(logname)
}

func NoTestQueryLogisticsInfo(t *testing.T) {
	l4g.LoadConfiguration("../config/logConfig.xml")
	logisticsInfo, err := Query("shentong", "668031148649")
	if err != nil {
		t.Fatal(err)
	}
	t.Log(logisticsInfo)
}

func main() {
	l4g.LoadConfiguration("./conf/log4go.xml")
	if beego.RunMode == "dev" {
		beego.DirectoryIndex = true
		beego.StaticDir["/swagger"] = "swagger"
	}
	beego.Run()
}

func main() {
	// Load the configuration (isn't this easy?)
	l4g.LoadConfiguration("example.xml")

	// And now we're ready!
	l4g.Finest("This will only go to those of you really cool UDP kids!  If you change enabled=true.")
	l4g.Debug("Oh no!  %d + %d = %d!", 2, 2, 2+2)
	l4g.Info("About that time, eh chaps?")
}

func main() {
	var err error
	flag.Parse()

	log.LoadConfiguration("logging.xml")

	// Load configuration
	alfConfig, err := config.NewConfig(*configPath)
	if err != nil {
		log.Error("Error parsing configuration: ", err.Error())
		os.Exit(1)
	}

	// Connect to the database
	alfDb := db.NewDB()
	err = alfDb.Connect(alfConfig.DbUrl)
	defer alfDb.Close()

	if err != nil {
		log.Error("Error connecting to DB: ", err.Error())
		os.Exit(1)
	}

	// Get all hosts, and all checks
	var hosts []db.Host
	err = alfDb.Hosts.FindAll(&hosts)
	if err != nil {
		log.Error("Failed to get hosts: ", err.Error())
		os.Exit(1)
	}
	log.Debug("Hosts: %v", hosts)

	var tasks []db.Task
	err = alfDb.Tasks.FindAll(&tasks)
	if err != nil {
		log.Error("Failed to get tasks: ", err.Error())
		os.Exit(1)
	}
	log.Debug("tasks: %v", tasks)

	// Run every task on every host
	for _, host := range hosts {
		for _, task := range tasks {
			runner := NewRunner(&host, &task, alfDb)
			// Launch runner in its own goroutine
			go runner.run()
		}

	}

	// Run HTTP API handlers
	httpService := http.NewHttpService(alfConfig.BindAddress, alfDb)
	go httpService.Start()

	// Block forever, exit with a SIGINT
	select {}
}

func main() {
	// init cmd args
	flag.Parse()
	// init config
	if err := initConfig(); err != nil {
		os.Exit(termExit)
	}
	// init log
	log.LoadConfiguration(conf.Log)
	defer log.Close()
	if len(conf.Sentinel) == 0 {
		// set to zk
		log.Error("conf.Sentinel don't have any sentinel addr")
		time.Sleep(logWait)
		os.Exit(retryExit)
	}
	log.Info("sentinels: \"%v\", master: \"%s\"", conf.Sentinel, conf.Master)
	// init sentinel addrs
	for _, addr := range conf.Sentinel {
		sentinelList.PushBack(addr)
	}
	redisConn := sentinel()
	if redisConn == nil {
		log.Error("sentinel can't connect")
		time.Sleep(logWait)
		os.Exit(retryExit)
	}
	defer redisConn.Close()
	// master redis
	redisMaster := masterAddr(redisConn)
	log.Debug("redis master: \"%s\"", redisMaster)
	isMaster := checkRole(redisMaster, roleMaster)
	if isMaster {
		refreshSentinel(redisConn)
	} else {
		log.Warn("abort the mission, master not ok")
		time.Sleep(logWait)
		os.Exit(retryExit)
	}
	// set to zk
	zkConn := zkDial()
	if zkConn == nil {
		log.Error("zookeeper can't connect")
		time.Sleep(logWait)
		os.Exit(retryExit)
	}
	defer zkConn.Close()
	if err := zkData(zkConn, redisMaster); err != nil {
		log.Error("zookeeper set data failed")
		time.Sleep(logWait)
		os.Exit(retryExit)
	}
	time.Sleep(logWait)
	os.Exit(okExit)
}

// 爬虫主程序
func main() {
	// l4g的配置文件
	l4g.LoadConfiguration(SPIDER_LOGCONF_XML)

	// refer : http://www.01happy.com/golang-command-line-arguments/
	var confPath string
	var logPath string
	var printVer bool

	flag.StringVar(&confPath, "c", "../../conf", "config file path")
	flag.StringVar(&logPath, "l", "../../log", "log file path")
	flag.BoolVar(&printVer, "v", false, "print version")

	flag.Parse()

	if printVer {
		utils.PrintVersion()
		os.Exit(0)
	}

	l4g.Info("Hi, dash's %s is running...\n", "go_mini_spider")

	confFile := confPath + "/" + SPIDER_CONFIG_FILE
	conf, err := conf.InitConf(confFile)
	if err != nil {
		l4g.Error("read spider config failed, err [%s]", err)
		SlowExit()
	}

	var seedUrls []string
	// read and parse json,相对路径
	b, err := ioutil.ReadFile(confPath + "/" + conf.UrlListFile)
	if err != nil {
		l4g.Error("readfile err[%s]", err)
		SlowExit()
	}
	//json to []string
	if err := json.Unmarshal(b, &seedUrls); err != nil {
		l4g.Error("parse json err[%s]", err)
		SlowExit()
	}

	//GOMAXPROCS设置
	runtime.GOMAXPROCS(runtime.NumCPU())

	// 启动爬虫
	spider := spider.NewSpider(seedUrls, conf, confPath)
	spider.Start()
	// 等待任务完成
	spider.Wait()

	time.Sleep(1 * time.Second)
}

func NoTestUpdateAndGetChangedLogistics(t *testing.T) {
	l4g.LoadConfiguration("../config/logConfig.xml")
	service, err := NewLogisticsService("../../db/pilogistics.db")
	if err != nil {
		t.Fatal(err)
	}
	logisticsCh := make(chan *ChangedLogisticsInfo, 1)
	go service.UpdateAndGetChangedLogistics(logisticsCh)
	for changedInfo := range logisticsCh {
		t.Log("username:", changedInfo.Username)
		for _, rec := range changedInfo.NewRecords {
			t.Log(rec)
		}
	}

}

func main() {
	flag.Parse()
	if err := InitConfig(); err != nil {
		panic(err)
	}
	runtime.GOMAXPROCS(Conf.MaxProc)
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	if Conf.Type == ProtoTCP {
		initTCP()
	} else if Conf.Type == ProtoWebsocket {
		initWebsocket()
	} else if Conf.Type == ProtoWebsocketTLS {
		initWebsocketTLS()
	}
}

func main() {
	flag.Parse()
	if err := InitConfig(); err != nil {
		panic(err)
	}
	runtime.GOMAXPROCS(Conf.MaxProc)
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	perf.Init(Conf.PprofBind)
	if Conf.Type == ProtoTCP {
		initTCP()
	} else if Conf.Type == ProtoWebsocket {
		initWebsocket()
	}
	time.Sleep(10 * time.Second)
}

func main() {
	// parse cmd-line arguments
	flag.Parse()
	log.Info("comet ver: \"%s\" start", ver.Version)
	// init config
	if err := InitConfig(); err != nil {
		panic(err)
	}
	// set max routine
	runtime.GOMAXPROCS(Conf.MaxProc)
	// init log
	log.LoadConfiguration(Conf.Log)
	defer log.Close()
	// start pprof
	perf.Init(Conf.PprofBind)
	// create channel
	// if process exit, close channel
	UserChannel = NewChannelList()
	defer UserChannel.Close()
	// start stats
	StartStats()
	// start rpc
	if err := StartRPC(); err != nil {
		panic(err)
	}
	// start comet
	if err := StartComet(); err != nil {
		panic(err)
	}
	// init zookeeper
	zkConn, err := InitZK()
	if err != nil {
		if zkConn != nil {
			zkConn.Close()
		}
		panic(err)
	}
	// process init
	if err = process.Init(Conf.User, Conf.Dir, Conf.PidFile); err != nil {
		panic(err)
	}
	// init signals, block wait signals
	signalCH := InitSignal()
	HandleSignal(signalCH)
	// exit
	log.Info("comet stop")
}

func main() {
	logger.LoadConfiguration("logging.xml")
	logger.Trace("main start")

	logger.Trace("CPU NUM: %d", runtime.NumCPU())
	runtime.GOMAXPROCS(runtime.NumCPU())

	//static directories
	http.Handle("/css/", http.StripPrefix("/css/", http.FileServer(http.Dir("./css/"))))
	http.Handle("/js/", http.StripPrefix("/js/", http.FileServer(http.Dir("./js/"))))
	http.Handle("/img/", http.StripPrefix("/img/", http.FileServer(http.Dir("./img/"))))

	handler.InitRoutes()

	http.HandleFunc("/", handler.RouteHandler)
	http.ListenAndServe(":8080", nil)
}

func main() {
	flag.Parse()
	if err := InitConfig(); err != nil {
		panic(err)
	}
	log.LoadConfiguration(Conf.Log)
	runtime.GOMAXPROCS(runtime.NumCPU())
	if err := InitComet(Conf.Comets); err != nil {
		panic(err)
	}
	InitPush()
	if err := InitKafka(); err != nil {
		panic(err)
	}
	// block until a signal is received.
	InitSignal()
}