Golang go-flags.ParseArgs函数代码示例

func main() {

	junk, err := flags.ParseArgs(&opts, os.Args)

	if len(junk) != 1 {
		fmt.Printf("Usage: Invalid arguments supplied, %s\n", junk)
		os.Exit(1)
	}
	if err != nil {
		os.Exit(1)
	}

	port = fmt.Sprintf("%d", opts.Port)
	if opts.HostIP != "localhost" {
		host_ip = opts.HostIP
	}

	server, err := socketio.NewServer(nil)
	if err != nil {
		log.Fatal(err)
	}
	server.On("connection", func(so socketio.Socket) {
		log.Println("on connection")
		so.Join("chat")
		so.On("chat message", func(msg string) {
			m := make(map[string]interface{})
			m["a"] = "你好" // hello there
			e := so.Emit("cn1111", m)
			//这个没有问题			// this is no problem
			fmt.Println("\n\n")

			b := make(map[string]string)
			b["u-a"] = "中文内容" //这个不能是中文		// this is chineese // this can not be chineese
			m["b-c"] = b
			e = so.Emit("cn2222", m)
			log.Println(e)

			log.Println("emit:", so.Emit("chat message", msg))
			so.BroadcastTo("chat", "chat message", msg)
		})
		so.On("t45", func(msg string) {
			err := so.Emit("r45", "Yep")
			if err != nil {
				fmt.Printf("Error: %s\n", err)
			}
		})
		so.On("disconnection", func() {
			log.Println("on disconnect")
		})
	})
	server.On("error", func(so socketio.Socket, err error) {
		log.Println("error:", err)
	})

	http.Handle("/socket.io/", server)
	http.Handle("/", http.FileServer(http.Dir("./asset")))
	fmt.Printf("Serving on port %s, brows to http://localhost:%s/\n", port, port)
	listen := fmt.Sprintf("%s:%s", host_ip, port)
	log.Fatal(http.ListenAndServe(listen, nil))
}

func TestCoreLoopRetryDidRetry(t *testing.T) {
	oldopts := opts
	defer func() { opts = oldopts }()

	statefile, err := ioutil.TempFile("./testdata", "")
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		os.Remove(statefile.Name())
		statefile.Close()
	}()

	arguments := "--retries=3 -- ./testdata/works-after-two-failures.sh " + statefile.Name()
	args, err := flags.ParseArgs(&opts, strings.Fields(arguments))
	if err != nil {
		t.Fatal(err)
	}

	var output bytes.Buffer
	var logstream bytes.Buffer

	log.SetOutput(&output)

	err = CoreLoopRetry(args, &logstream)
	t.Log(output.String())
	t.Log(logstream.String())
	if err != nil {
		t.Error("want no error, got", err)
	}
}

func main() {

	_, err := flags.ParseArgs(&opts, os.Args)
	if err != nil {
		os.Exit(1)
	}

	if opts.ClearTopic {
		clearTopic(opts.Topic)
	}

	if opts.KeyPrefix != "" {
		KEY_PREFIX = opts.KeyPrefix + "-"
	}

	if opts.ProcessorHost != "" {
		if !strings.HasSuffix(opts.ProcessorHost, "/") {
			PROCESSOR_HOST = opts.ProcessorHost
		} else {
			fmt.Println("Cannot have a hostname that ends with a slash, try again.")
			os.Exit(1)
		}
	}

	if opts.ProcessorPort != "" {
		PROCESSOR_PORT = opts.ProcessorPort
	}

	err = filepath.Walk(string(opts.Path), visit)
	if err != nil {
		fmt.Printf("Error saving log files: %s\n", err)
	}
}

func init() {
	_, err := flags.ParseArgs(&options, os.Args)

	if err != nil {
		os.Exit(1)
	}
}

func main() {
	var opts struct {
		DBPath   string `short:"f" long:"file" description:"Path to GeoIP database" value-name:"FILE" default:""`
		Listen   string `short:"l" long:"listen" description:"Listening address" value-name:"ADDR" default:":8080"`
		CORS     bool   `short:"x" long:"cors" description:"Allow requests from other domains" default:"false"`
		Template string `short:"t" long:"template" description:"Path to template" default:"index.html"`
	}
	_, err := flags.ParseArgs(&opts, os.Args)
	if err != nil {
		os.Exit(1)
	}

	var a *api.API
	if opts.DBPath == "" {
		a = api.New()
	} else {
		a, err = api.NewWithGeoIP(opts.DBPath)
		if err != nil {
			log.Fatal(err)
		}
	}

	a.CORS = opts.CORS
	a.Template = opts.Template

	log.Printf("Listening on %s", opts.Listen)
	if err := a.ListenAndServe(opts.Listen); err != nil {
		log.Fatal(err)
	}
}

func getDefaultOptions() *options {
	opts := &options{}
	if _, err := gflags.ParseArgs(opts, nil); err != nil {
		panic(err)
	}
	opts.PProfOptions.BinaryFile = testPProfInputFile
	return opts
}

func TestPuppetDetailedExitCodes(t *testing.T) {
	oldopts := opts
	defer func() { opts = oldopts }()

	arguments := "--monitor-ok=2 --monitor-warning=4 --monitor-warning=6 --monitor-critical=1 -- true"
	_, err := flags.ParseArgs(&opts, strings.Fields(arguments))
	err = validateOptionConstraints()
	if err != nil {
		t.Errorf("want no error, got %s", err)
	}
}

func TestDefaulSettingsOk(t *testing.T) {
	oldopts := opts
	defer func() { opts = oldopts }()

	arguments := "-- true"
	_, err := flags.ParseArgs(&opts, strings.Fields(arguments))
	err = validateOptionConstraints()
	if err != nil {
		t.Errorf("want no error, got %s", err)
	}

}

func runWithArgs(args ...string) error {
	opts := &options{}
	if _, err := gflags.ParseArgs(opts, args); err != nil {
		if flagErr, ok := err.(*gflags.Error); ok && flagErr.Type == gflags.ErrHelp {
			os.Exit(0)
		}
		return fmt.Errorf("could not parse options: %v", err)
	}
	if err := validateOptions(opts); err != nil {
		return fmt.Errorf("invalid options: %v", err)
	}

	return runWithOptions(opts)
}

func TestCoreLoopOncePosixExitHandling(t *testing.T) {
	testone := func(arguments string) (error, monitoringResult) {
		logbuf := func(t *testing.T, buf *bytes.Buffer) {
			if buf.Len() > 0 {
				t.Log(buf.String())
			}
		}

		var output bytes.Buffer
		defer logbuf(t, &output)
		log.SetOutput(&output)
		defer log.SetOutput(&bytes.Buffer{})

		oldopts := opts
		defer func() { opts = oldopts }()

		args, err := flags.ParseArgs(&opts, strings.Fields(arguments))
		if err != nil {
			t.Fatal(err)
		}

		err = validateOptionConstraints()
		if err != nil {
			t.Fatal(err)
		}

		var logstream bytes.Buffer
		defer logbuf(t, &logstream)

		err = CoreLoopOnce(args, &logstream)
		code, _ := error2exit(err)

		return err, code
	}

	for i := 1; i < 256; i++ {
		err, code := testone(fmt.Sprintf("-- ./testdata/exit_with_code.sh %d", i))
		if code != monitorCritical {
			t.Errorf("want CRITICAL monitoring state for exit code %d, got %s due to err = %v", i, code, err)
		}
	}

	for i := monitorOk; i <= monitorUnknown; i++ {
		err, code := testone(fmt.Sprintf("--wrap-nagios-plugin -- ./testdata/exit_with_code.sh %d", i))
		if code != i {
			t.Errorf("want %s monitoring state, got %s due to err = %v", i, code, err)
		}
	}
}

func main() {
	var opts struct {
		CountryDBPath string `short:"f" long:"country-db" description:"Path to GeoIP country database" value-name:"FILE" default:""`
		CityDBPath    string `short:"c" long:"city-db" description:"Path to GeoIP city database" value-name:"FILE" default:""`
		Listen        string `short:"l" long:"listen" description:"Listening address" value-name:"ADDR" default:":8080"`
		ReverseLookup bool   `short:"r" long:"reverse-lookup" description:"Perform reverse hostname lookups"`
		PortLookup    bool   `short:"p" long:"port-lookup" description:"Enable port lookup"`
		Template      string `short:"t" long:"template" description:"Path to template" default:"index.html"`
		IPHeader      string `short:"H" long:"trusted-header" description:"Header to trust for remote IP, if present (e.g. X-Real-IP)"`
	}
	_, err := flags.ParseArgs(&opts, os.Args)
	if err != nil {
		os.Exit(1)
	}

	oracle := api.NewOracle()
	if opts.ReverseLookup {
		log.Println("Enabling reverse lookup")
		oracle.EnableLookupAddr()
	}
	if opts.PortLookup {
		log.Println("Enabling port lookup")
		oracle.EnableLookupPort()
	}
	if opts.CountryDBPath != "" {
		log.Printf("Enabling country lookup (using database: %s)", opts.CountryDBPath)
		if err := oracle.EnableLookupCountry(opts.CountryDBPath); err != nil {
			log.Fatal(err)
		}
	}
	if opts.CityDBPath != "" {
		log.Printf("Enabling city lookup (using database: %s)", opts.CityDBPath)
		if err := oracle.EnableLookupCity(opts.CityDBPath); err != nil {
			log.Fatal(err)
		}
	}
	if opts.IPHeader != "" {
		log.Printf("Trusting header %s to contain correct remote IP", opts.IPHeader)
	}

	api := api.New(oracle)
	api.Template = opts.Template
	api.IPHeader = opts.IPHeader

	log.Printf("Listening on %s", opts.Listen)
	if err := api.ListenAndServe(opts.Listen); err != nil {
		log.Fatal(err)
	}
}

func TestCoreLoopOnceExitSuccess(t *testing.T) {
	oldopts := opts
	defer func() { opts = oldopts }()

	arguments := "-- true"
	args, err := flags.ParseArgs(&opts, strings.Fields(arguments))
	if err != nil {
		t.Fatal(err)
	}

	var output bytes.Buffer
	log.SetOutput(&output)

	err = CoreLoopOnce(args, &bytes.Buffer{})
	t.Log(output.String())
	if err != nil {
		t.Error("want no error, got", err)
	}
}

func main() {
	_, err := flags.ParseArgs(&opts, os.Args)
	PanicIf(err)

	m := martini.Classic()
	m.Map(SetupDB())

	// Serve static files from "static" directory.
	StaticOptions := martini.StaticOptions{Prefix: "static"}
	m.Use(martini.Static(opts.StaticDir, StaticOptions))

	// Render html templates from "templates" directory.
	m.Use(render.Renderer(render.Options{Directory: opts.TemplatesDir}))

	m.Get("/", IndexHandler)
	m.Post("/subscribe/", binding.Form(Subscription{}), SubscribeHandler)

	m.Run()
}

func TestCoreLoopRetryExitSuccessFunnyExitCodes(t *testing.T) {
	oldopts := opts
	defer func() { opts = oldopts }()

	arguments := "--retries=3 --monitor-ok=1 -- false"
	args, err := flags.ParseArgs(&opts, strings.Fields(arguments))
	if err != nil {
		t.Fatal(err)
	}

	var output bytes.Buffer
	log.SetOutput(&output)

	err = CoreLoopRetry(args, &bytes.Buffer{})
	t.Log(output.String())
	if err != nil {
		t.Error("want no error, got", err)
	}
}

func parseFlags(flags interface{}, args []string) []string {
	args, err := goflags.ParseArgs(flags, args)
	if err != nil {
		// assert the err to be a flags.Error
		flagError := err.(*goflags.Error)
		if flagError.Type == goflags.ErrHelp {
			// user asked for help on flags.
			// program can exit successfully
			os.Exit(0)
		}
		if flagError.Type == goflags.ErrUnknownFlag {
			fmt.Println("Use --help to view all available options.")
			os.Exit(1)
		}
		fmt.Printf("Error parsing flags: %s\n", err)
		os.Exit(1)
	}
	return args
}