func main() {

	role := flag.String("role", "master", "Escort role")
	flag.Set("alsologtostderr", "true")
	flag.Set("v", "5")
	flag.Parse()

	if role == nil || len(*role) == 0 {
		Usage()
		return
	}

	glog.Infoln(*role)

	switch *role {
	case "master":
		// 主服务
		server.Work()
	case "slave":
		// 备份服务
		client.Work()
	default:
		Usage()
	}
}

// ExampleFlightGetBadID tests giving a non integer as ID value, with null output
func ExampleFlightGetBadID() {
	_ = flag.Set("id", "i")
	_ = flag.Set("startID", "")
	_ = flag.Set("max", "")
	runFlightGet(CmdFlightGet, []string{})
	// Output:
}

func Init() error {
	Program = filepath.Base(os.Args[0])
	if !isPidInitialize() {
		if "windows" == runtime.GOOS {
			flag.Set("pid_file", Program+".pid")
		} else {
			flag.Set("pid_file", "/var/run/"+Program+".pid")
		}
	}

	if "." == RootDir {
		RootDir = abs(filepath.Dir(os.Args[0]))
		dirs := []string{abs(filepath.Dir(os.Args[0])), filepath.Join(abs(filepath.Dir(os.Args[0])), "..")}
		for _, s := range dirs {
			if DirExists(filepath.Join(s, "conf")) {
				RootDir = s
				break
			}
		}
	} else {
		RootDir = abs(RootDir)
	}

	if !DirExists(RootDir) {
		return errors.New("root directory '" + RootDir + "' is not exist.")
	} else {
		log.Println("root directory is '" + RootDir + "'.")
	}

	e := os.Chdir(RootDir)
	if nil != e {
		log.Println("change current dir to \""+RootDir+"\",", e)
	}
	return nil
}

func init() {
	sdk := env.URL(nil)
	if sdk != "" {
		flag.Set("sdk", sdk)
		flag.Set("vm-path", "docker-appliance")
		flag.Set("cluster", os.Getenv("GOVC_CLUSTER"))
	}

	// fake up a docker-host for pprof collection
	u := url.URL{Scheme: "http", Host: "127.0.0.1:6060"}

	go func() {
		log.Println(http.ListenAndServe(u.Host, nil))
	}()

	transport := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	insecureClient = &http.Client{Transport: transport}
	flag.Set("docker-host", u.Host)

	config.hostCertFile = "fixtures/vicadmin_test_cert.pem"
	config.hostKeyFile = "fixtures/vicadmin_test_pkey.pem"

	cert, cerr := ioutil.ReadFile(config.hostCertFile)
	key, kerr := ioutil.ReadFile(config.hostKeyFile)
	if kerr != nil || cerr != nil {
		panic("unable to load test certificate")
	}
	vchConfig.HostCertificate = &vchconfig.RawCertificate{
		Cert: cert,
		Key:  key,
	}
}

func main() {
	mrand.Seed(time.Now().UnixNano())
	errors := []error{
		flag.Set("logtostderr", "true"),
		flag.Set("logcolor", "true"),
	}
	for _, err := range errors {
		if err != nil {
			panic(err)
		}
	}
	lg.SetSrcHighlight("alkasir/cmd", "alkasir/pkg")
	lg.CopyStandardLogTo("info")
	flag.Parse()
	flagenv.Prefix = "ALKASIR_"
	flagenv.Parse()
	err := commandHandler(flag.Args())
	if err != nil {
		if err == errCommandNotFound {
			fmt.Println("")
			fmt.Println("Command index:")
			fmt.Println("")
			rootCommand.PrintHelp("alkasir-admin", 0)
			fmt.Println("")
			os.Exit(1)
		}
		lg.Fatal(err)
		os.Exit(1)
	}

}

func loadConfig() {
	var cfgPath string
	cfgPath = os.Getenv("HOME")
	if cfgPath != "" {
		cfgPath = cfgPath + "/.config"
		err := verifyOrCreateDirectory(cfgPath)
		if err != nil {
			panic(err)
		}
		cfgPath = cfgPath + "/magopie-cui"
	}
	if cfgPath != "" {
		file, err := os.Open(cfgPath)
		if err != nil {
			// Couldn't load config even though one was specified
			return
		}
		defer file.Close()
		scanner := bufio.NewScanner(file)
		for scanner.Scan() {
			tstString := scanner.Text()
			if strings.HasPrefix(tstString, "server=") {
				prts := strings.Split(tstString, "=")
				if len(prts) > 1 {
					flag.Set("http", prts[1])
				}
			} else if strings.HasPrefix(tstString, "key=") {
				prts := strings.Split(tstString, "=")
				if len(prts) > 1 {
					flag.Set("key", prts[1])
				}
			}
		}
	}
}

func Start(port string, onStart func()) {

	// Logging init
	flag.Set("log_dir", utils.GetRuntimeDir(config.GetString("log_dir")))
	flag.Set("alsologtostderr", "true")
	flag.Parse()
	defer glog.Flush()

	m := martini.Classic()
	m.Use(render.Renderer(render.Options{
		Charset:   "UTF-8", // Sets encoding for json and html content-types. Default is "UTF-8".
		Delims:    render.Delims{"${", "}"},
		Directory: utils.GetRuntimeDir("resources/views"),
	}))

	m.Use(martini.Static(utils.GetRuntimeDir("public")))
	controller.MappingController(m)

	http.Handle("/rpc", rpc.GetServer())
	http.Handle("/", m)

	if db.IsConnected() {
		defer db.Close()
	}

	onStart()

	for _, fn := range methods {
		go fn()
	}

	http.ListenAndServe(":"+port, nil)
}

func (delegate *TestClientDelegate) Initialize(ctx application.Context) {
	log.Printf("TestClientDelegate.Initialize...")

	// Set the necessary flags using the mojo args.
	args := ctx.Args()
	mojoFlag = flag.NewFlagSet(args[0], flag.ExitOnError)
	mojoRun := mojoFlag.String("test.run", "", "")
	mojoBench := mojoFlag.String("test.bench", "", "")
	endpointFlag = mojoFlag.String("endpoint", "", "")
	v23TcpAddr := mojoFlag.String("v23.tcp.address", "", "")
	mojoFlag.Parse(args[1:])
	flag.Set("test.run", *mojoRun)
	flag.Set("test.bench", *mojoBench)
	flag.Set("v23.tcp.address", *v23TcpAddr)

	tests := []func(*testing.T, application.Context){
		TestSimple, TestMultiArgs, TestReuseProxy, TestNoOutArgs,
	}
	benchmarks := []func(*testing.B, application.Context){
		BenchmarkSimpleRpc,
	}

	matchAllTests := func(pat, str string) (bool, error) { return true, nil }
	exitCode := testing.MainStart(matchAllTests, convertTests(tests, ctx), convertBenchmarks(benchmarks, ctx), nil).Run()
	if exitCode == 0 {
		fmt.Printf("%s\n", expected.SuccessMessage)
	} else {
		fmt.Printf("%s\n", expected.FailureMessage)
	}

	ctx.Close()
	os.Exit(exitCode)
}

// ExampleFlightGetByID uses the mock flight implementation to query data and
// verify flight-get works. First, a specific id is passed. Second, a start id
// is passed.
func ExampleFlightGetByID() {
	plugin.Register("mockflightgetbyid", &mock.Mock{
		GetFlightByIDF: func(id int) (flight.Flight, error) {
			f := flight.Flight{
				Header: flight.Header{
					Date:       time.Date(2015, 1, 10, 0, 0, 0, 0, time.UTC),
					Pilot:      "MOCK PILOT 1",
					GliderType: "MOCK GLIDER 1", GliderID: "MOCK ID 1",
				},
				Sources: map[string]flight.Source{
					"netcoupe": flight.Source{
						Name:     "MOCK NAME 1",
						Category: "MOCK CATEGORY 1",
						Club:     "MOCK CLUB 1",
						Region:   "MOCK REGION 1",
						Country:  "MOCK COUNTRY 1",
						Distance: 100.01, Points: 100.02,
					},
				},
			}
			return f, nil
		},
	},
	)
	config.Set(config.Config{Global: config.Global{Flighter: "mockflightgetbyid"}})
	_ = flag.Set("id", "1")
	_ = flag.Set("startID", "")
	_ = flag.Set("max", "")
	runFlightGet(CmdFlightGet, []string{})
	// Output:
	// 10/01/2015,MOCK PILOT 1,MOCK GLIDER 1,MOCK ID 1
	//	netcoupe,MOCK NAME 1,MOCK CATEGORY 1,MOCK CLUB 1,MOCK COUNTRY 1,MOCK REGION 1,100.01,100.02
}

func init() {

	if os.Getenv("DATABASE_URL") != "" {
		flag.Set("driver", "postgres")
		flag.Set("dbsource", os.Getenv("DATABASE_URL"))
		log.Println("Using PostgreSQL")
	} else {
		log.Println("Using SQLite3")
	}

	db, err := gorm.Open(*driver, *dbsource)

	if err != nil {
		panic(err)
	}

	db.LogMode(false)

	// Here database and tables are created in case they do not exist yet.
	// If database or tables do exist, nothing will happen to the original ones.
	db.CreateTable(&User{})
	db.CreateTable(&Post{})
	db.AutoMigrate(&User{}, &Post{})

	connection.SQL = db.DB()
	connection.Gorm = db
}

func (s *MainSuite) TestGenApi(c *C) {
	flag.Set("pkg", "github.com/hypermusk/hypermusk/tests/api")
	flag.Set("lang", "objc")
	flag.Set("outdir", "tests")
	flag.Set("impl", "github.com/hypermusk/hypermusk/tests/apiimpl")
	genApi()
}

func main() {
	defer glog.Flush()
	flag.Set("logtostderr", "true")
	flag.Set("v", "2")
	flag.Parse()

	// Add actions sources
	for _, source := range strings.Split(sources, ",") {
		core.Source(source)
	}

	// Executor
	ex := executor.New(tests)

	// API
	http.Handle("/watch", api.WatchHandler{Executor: ex})
	http.Handle("/execute", api.ExecuteHandler{Executor: ex})
	http.Handle("/status/poll", api.PollHandler{Executor: ex})
	http.Handle("/status", api.StatusHandler{Executor: ex})
	http.Handle("/latest", api.LatestHandler{Executor: ex})

	// Dashboard
	http.Handle("/", http.FileServer(http.Dir(dashboard)))

	if watch {
		go ex.Watch()
	}

	// Start listening
	glog.Infof("Listening on address %s\n", listenaddr)
	glog.Fatal(http.ListenAndServe(listenaddr, nil))
}

// TestNewRestartableResultReader tests the correct error handling e.g.
// if the connection to a tablet fails due to a canceled context.
func TestNewRestartableResultReader(t *testing.T) {
	wantErr := errors.New("restartable_result_reader_test.go: context canceled")

	tabletconn.RegisterDialer("fake_dialer", func(tablet *topodatapb.Tablet, timeout time.Duration) (tabletconn.TabletConn, error) {
		return nil, wantErr
	})
	protocol := flag.CommandLine.Lookup("tablet_protocol").Value.String()
	flag.Set("tablet_protocol", "fake_dialer")
	// Restore the previous flag value after the test.
	defer flag.Set("tablet_protocol", protocol)

	// Create dependencies e.g. a "singleTabletProvider" instance.
	ts := zktestserver.New(t, []string{"cell1"})
	wr := wrangler.New(logutil.NewConsoleLogger(), ts, tmclient.NewTabletManagerClient())
	alias := &topodatapb.TabletAlias{
		Cell: "cell1",
		Uid:  1,
	}
	tablet := &topodatapb.Tablet{
		Keyspace: "ks1",
		Shard:    "-80",
		Alias:    alias,
	}
	ctx := context.Background()
	if err := ts.CreateTablet(ctx, tablet); err != nil {
		t.Fatalf("CreateTablet failed: %v", err)
	}
	tp := newSingleTabletProvider(ctx, ts, alias)

	_, err := NewRestartableResultReader(ctx, wr.Logger(), tp, nil /* td */, chunk{}, false)
	if err == nil || !strings.Contains(err.Error(), wantErr.Error()) {
		t.Fatalf("NewRestartableResultReader() should have failed because the context is canceled: %v", err)
	}
}

// NewVtctlPipe creates a new VtctlPipe based on the given topo server.
func NewVtctlPipe(t *testing.T, ts topo.Server) *VtctlPipe {
	// Register all vtctl commands
	servenvInitialized.Do(func() {
		// make sure we use the right protocol
		flag.Set("vtctl_client_protocol", "grpc")

		// Enable all query groups
		flag.Set("enable_queries", "true")
		servenv.FireRunHooks()
	})

	// Listen on a random port
	listener, err := net.Listen("tcp", ":0")
	if err != nil {
		t.Fatalf("Cannot listen: %v", err)
	}

	// Create a gRPC server and listen on the port
	server := grpc.NewServer()
	grpcvtctlserver.StartServer(server, ts)
	go server.Serve(listener)

	// Create a VtctlClient gRPC client to talk to the fake server
	client, err := vtctlclient.New(listener.Addr().String(), 30*time.Second)
	if err != nil {
		t.Fatalf("Cannot create client: %v", err)
	}

	return &VtctlPipe{
		listener: listener,
		client:   client,
		t:        t,
	}
}

// ExampleFlightGetFromID queries using flight-get. First no max is given, so all records
// starting at 'startID' are returned. Second, a max is given so the number of results is limited.
func ExampleFlightGetFromID() {
	plugin.Register("mockflightgetfromid", &mock.Mock{
		GetFlightFromIDF: func(startID int, max int) ([]flight.Flight, error) {
			flights := []flight.Flight{
				flight.Flight{
					Header: flight.Header{
						Date:       time.Date(2015, 1, 10, 0, 0, 0, 0, time.UTC),
						Pilot:      "MOCK PILOT 1",
						GliderType: "MOCK GLIDER 1", GliderID: "MOCK ID 1",
					},
					Sources: map[string]flight.Source{
						"netcoupe": flight.Source{
							Name:     "MOCK NAME 1",
							Category: "MOCK CATEGORY 1",
							Club:     "MOCK CLUB 1",
							Region:   "MOCK REGION 1",
							Country:  "MOCK COUNTRY 1",
							Distance: 101.01, Points: 101.02,
						},
					},
				},
				flight.Flight{
					Header: flight.Header{
						Date:       time.Date(2015, 1, 11, 0, 0, 0, 0, time.UTC),
						Pilot:      "MOCK PILOT 2",
						GliderType: "MOCK GLIDER 2", GliderID: "MOCK ID 2",
					},
					Sources: map[string]flight.Source{
						"netcoupe": flight.Source{
							Name:     "MOCK NAME 2",
							Category: "MOCK CATEGORY 2",
							Club:     "MOCK CLUB 2",
							Region:   "MOCK REGION 2",
							Country:  "MOCK COUNTRY 2",
							Distance: 102.01, Points: 102.02,
						},
					},
				},
			}
			if max > 0 {
				flights = flights[0:max]
			}
			return flights, nil
		},
	},
	)
	config.Set(config.Config{Global: config.Global{Flighter: "mockflightgetfromid"}})
	_ = flag.Set("startID", "1")
	_ = flag.Set("max", "")
	runFlightGet(CmdFlightGet, []string{})
	_ = flag.Set("max", "1")
	runFlightGet(CmdFlightGet, []string{})
	// Output:
	// 10/01/2015,MOCK PILOT 1,MOCK GLIDER 1,MOCK ID 1
	//	netcoupe,MOCK NAME 1,MOCK CATEGORY 1,MOCK CLUB 1,MOCK COUNTRY 1,MOCK REGION 1,101.01,101.02
	// 11/01/2015,MOCK PILOT 2,MOCK GLIDER 2,MOCK ID 2
	//	netcoupe,MOCK NAME 2,MOCK CATEGORY 2,MOCK CLUB 2,MOCK COUNTRY 2,MOCK REGION 2,102.01,102.02
	// 10/01/2015,MOCK PILOT 1,MOCK GLIDER 1,MOCK ID 1
	//	netcoupe,MOCK NAME 1,MOCK CATEGORY 1,MOCK CLUB 1,MOCK COUNTRY 1,MOCK REGION 1,101.01,101.02
}

func main() {
	flag.Parse()
	args := flag.Args()

	// check environment variables
	if *host == "localhost:27017" {
		if env := os.Getenv("GODMHOST"); env != "" {
			flag.Set("host", env)
		}
	}
	if *database == "test" {
		if env := os.Getenv("GODMDB"); env != "" {
			flag.Set("db", env)
		}
	}

	db := &Db{*host, *database}

	if len(args) == 0 {
		helpFunc(db, nil, args)
		os.Exit(1)
	}

	cmdName, args := args[0], args[1:]
	if cmd := findCommand(cmdName); cmd != nil {
		cmd.Run(db, args)
	} else {
		log.Fatal("Unknown command. 'help' for usage.")
	}
}

// InitLogs initializes logs the way we want for SkyRing.
func InitLogs(logConf conf.SkyringLogging) {
	flag.Parse()
	flag.Set("logtostderr", strconv.FormatBool(logConf.Logtostderr))
	flag.Set("log_dir", logConf.Log_dir)
	flag.Set("v", strconv.Itoa(logConf.V))
	// The default glog flush interval is 30 seconds, which is frighteningly long.
	go Forever(glog.Flush, 5*time.Second)
}

func test_storage_init() (err error) {
	runtime.GOMAXPROCS(runtime.NumCPU())
	flag.Set("alsologtostderr", "true")
	flag.Set("v", "2")
	flag.Parse()

	storageApp = &Backend{
		ShmMagic: 0x80386,
		ShmKey:   0x6020,
		ShmSize:  1 << 28, // 256m
		Storage: Storage{
			Type: "rrdlite",
		},
	}

	testDirs = make([]string, MAX_HD_NUMBER)

	for i := 0; i < MAX_HD_NUMBER; i++ {
		testDirs[i] = fmt.Sprintf("%s/hdd%d/test", testDir, i+1)
		os.RemoveAll(testDirs[i])
		os.MkdirAll(testDirs[i], 0755)
	}

	err = storageCheckHds(testDirs)
	if err != nil {
		glog.Fatalf(MODULE_NAME+"rrdtool.Start error, bad data dir %v\n", err)
	}

	storageApp.storageIoTaskCh = make([]chan *ioTask, MAX_HD_NUMBER)
	for i := 0; i < MAX_HD_NUMBER; i++ {
		storageApp.storageIoTaskCh[i] = make(chan *ioTask, 320)
		go storageApp.ioWorker(storageApp.storageIoTaskCh[i])
	}

	storageApp.cacheInit()
	if err := storageApp.cacheReset(); err != nil {
		fmt.Println(err)
	}

	storageApp.timeStart()
	now = time.Now().Unix()
	storageApp.ts = now

	for i := 0; i < MAX_HD_NUMBER; i++ {
		item := newRrdItem2(i, now)
		for j := 0; j < benchSize; j++ {
			es[i][j], err = storageApp.rrdToEntry(item)
			if err != nil {
				glog.Infof("benchmarkAdd %s\n", err)
				return err
			}
			es[i][j].setName(fmt.Sprintf("key_%d_%d", i, j))
			es[i][j].setHashkey(es[i][j].csum())
		}
	}
	return nil
}

func init() {
	/*
	**To configure glog
	 */
	flag.Set("logtostderr", "true")
	flag.Set("log_dir", ".")
	flag.Set("V", "3")
	flag.Parse()
}

func main() {
	flag.Set("test.bench", "Large")
	flag.Set("test.v", "true")

	testing.Main(func(pat, str string) (bool, error) { return true, nil },
		[]testing.InternalTest{{"TestLargeMapGC", TestLargeMapGC}},
		[]testing.InternalBenchmark{{"BenchmarkLargeMapGC", BenchmarkLargeMapGC}},
		[]testing.InternalExample{})
}