Golang pflag.NormalizedName函数代码示例

// WarnWordSepNormalizeFunc changes and warns for flags that contain "_" separators
func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
	if strings.Contains(name, "_") {
		nname := strings.Replace(name, "_", "-", -1)
		glog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", name, nname)

		return pflag.NormalizedName(nname)
	}
	return pflag.NormalizedName(name)
}

func main() {
	// configuration
	cfg := pkg.NewConfig()

	// flags
	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
	fs.StringVar(&cfg.IngressesData, "ingresses-data", cfg.IngressesData, "Ingresses data.")
	fs.StringVar(&cfg.KubeMasterURL, "kube-master-url", cfg.KubeMasterURL, "URL to reach kubernetes master.")
	fs.StringVar(&cfg.Namespace, "namespace", cfg.Namespace, "If present, the namespace scope.")
	fs.StringVar(&cfg.Selector, "selector", cfg.Selector, "Filter resources by a user-provided selector.")
	fs.DurationVar(&cfg.ResyncInterval, "resync-interval", cfg.ResyncInterval, "Resync with kubernetes master every user-defined interval.")
	fs.StringVar(&cfg.NginxSrc, "nginx-src", cfg.NginxSrc, "nginx.conf template file path.")
	fs.StringVar(&cfg.NginxDest, "nginx-dst", cfg.NginxDest, "nginx.conf destination file path.")
	fs.IntVar(&cfg.NginxDestUid, "nginx-dst-uid", cfg.NginxDestUid, "nginx.conf destination file uid.")
	fs.IntVar(&cfg.NginxDestGid, "nginx-dst-gid", cfg.NginxDestGid, "nginx.conf destination file gid.")
	fs.StringVar(&cfg.NginxDestMode, "nginx-dst-mode", cfg.NginxDestMode, "nginx.conf destination file mode.")
	fs.StringVar(&cfg.NginxCheckCmd, "nginx-check-cmd", cfg.NginxCheckCmd, "nginx check command.")
	fs.StringVar(&cfg.NginxReloadCmd, "nginx-reload-cmd", cfg.NginxReloadCmd, "nginx reload command.")
	fs.SetNormalizeFunc(
		func(f *flag.FlagSet, name string) flag.NormalizedName {
			if strings.Contains(name, "_") {
				return flag.NormalizedName(strings.Replace(name, "_", "-", -1))
			}
			return flag.NormalizedName(name)
		},
	)

	// parse
	fs.Parse(os.Args[1:])

	// set from env (if present)
	fs.VisitAll(func(f *flag.Flag) {
		if !f.Changed {
			key := strings.ToUpper(strings.Join(
				[]string{
					cliName,
					strings.Replace(f.Name, "-", "_", -1),
				},
				"_",
			))
			val := os.Getenv(key)
			if val != "" {
				fs.Set(f.Name, val)
			}
		}
	})

	// and then, run!
	k2n := pkg.NewKubeToNginx(cfg)
	k2n.Run()
}

func main() {
	// configuration
	cfg := pkg.NewConfig()

	// flags
	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
	fs.StringVar(&cfg.Me, "me", cfg.Me, "me.")
	fs.StringVar(&cfg.Members, "members", cfg.Members, "members.")
	fs.StringVar(&cfg.TmplListenUrl, "tmpl-listen-url", cfg.TmplListenUrl, "tmpl-listen-url.")
	fs.StringVar(&cfg.TmplPeerUrl, "tmpl-peer-url", cfg.TmplPeerUrl, "tmpl-peer-url.")
	fs.StringVar(&cfg.CertFile, "cert-file", cfg.CertFile, "Identify HTTPS client using this SSL certificate file.")
	fs.StringVar(&cfg.KeyFile, "key-file", cfg.KeyFile, "Identify HTTPS client using this SSL key file.")
	fs.StringVar(&cfg.CAFile, "ca-file", cfg.CAFile, "Verify certificates of HTTPS-enabled servers using this CA bundle.")
	fs.BoolVar(&cfg.Force, "force", cfg.Force, "force.")
	fs.StringVar(&cfg.Out, "out", cfg.Out, "etcd2 peers environment file destination")
	fs.SetNormalizeFunc(
		func(f *flag.FlagSet, name string) flag.NormalizedName {
			if strings.Contains(name, "_") {
				return flag.NormalizedName(strings.Replace(name, "_", "-", -1))
			}
			return flag.NormalizedName(name)
		},
	)

	// parse
	fs.Parse(os.Args[1:])

	// set from env (if present)
	fs.VisitAll(func(f *flag.Flag) {
		if !f.Changed {
			key := strings.ToUpper(strings.Join(
				[]string{
					cliName,
					strings.Replace(f.Name, "-", "_", -1),
				},
				"_",
			))
			val := os.Getenv(key)
			if val != "" {
				fs.Set(f.Name, val)
			}
		}
	})

	// and then, run!
	eb := pkg.NewEtcd2Bootstrapper(cfg)
	eb.Run()
}

func main() {
	// configuration
	cfg := pkg.NewConfig()

	// flags
	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
	fs.StringVar(&cfg.KubeMasterURL, "kube-master-url", cfg.KubeMasterURL, "URL to reach kubernetes master.")
	fs.StringVar(&cfg.Namespace, "namespace", cfg.Namespace, "If present, the namespace scope.")
	fs.StringVar(&cfg.Resource, "resource", cfg.Resource, "Which resource to watch.")
	fs.StringVar(&cfg.Selector, "selector", cfg.Selector, "Filter resources by a user-provided selector.")
	fs.DurationVar(&cfg.ResyncInterval, "resync-interval", cfg.ResyncInterval, "Resync with kubernetes master every user-defined interval.")
	fs.StringVar(&cfg.AddEventsFile, "add-events-file", cfg.AddEventsFile, "File in which the events of type 'add' are printed.")
	fs.StringVar(&cfg.UpdateEventsFile, "update-events-file", cfg.UpdateEventsFile, "File in which the events of type 'update' are printed.")
	fs.StringVar(&cfg.DeleteEventsFile, "delete-events-file", cfg.DeleteEventsFile, "File in which the events of type 'delete' are printed.")
	fs.SetNormalizeFunc(
		func(f *flag.FlagSet, name string) flag.NormalizedName {
			if strings.Contains(name, "_") {
				return flag.NormalizedName(strings.Replace(name, "_", "-", -1))
			}
			return flag.NormalizedName(name)
		},
	)

	// parse
	fs.Parse(os.Args[1:])

	// set from env (if present)
	fs.VisitAll(func(f *flag.Flag) {
		if !f.Changed {
			key := strings.ToUpper(strings.Join(
				[]string{
					cliName,
					strings.Replace(f.Name, "-", "_", -1),
				},
				"_",
			))
			val := os.Getenv(key)
			if val != "" {
				fs.Set(f.Name, val)
			}
		}
	})

	// and then, run!
	kl := pkg.NewKubeListener(cfg)
	kl.Run()
}

func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
	from := []string{"-", "_"}
	to := "."
	for _, sep := range from {
		name = strings.Replace(name, sep, to, -1)
	}
	// Type convert to indicate normalization has been done.
	return pflag.NormalizedName(name)
}

// NormalizeHugoFlags facilitates transitions of Hugo command-line flags,
// e.g. --baseUrl to --baseURL, --uglyUrls to --uglyURLs
func NormalizeHugoFlags(f *pflag.FlagSet, name string) pflag.NormalizedName {
	switch name {
	case "baseUrl":
		name = "baseURL"
		break
	case "uglyUrls":
		name = "uglyURLs"
		break
	}
	return pflag.NormalizedName(name)
}

func TestGlobalNormFuncPropagation(t *testing.T) {
	normFunc := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
		return pflag.NormalizedName(name)
	}

	rootCmd := initialize()
	rootCmd.SetGlobalNormalizationFunc(normFunc)
	if reflect.ValueOf(normFunc) != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()) {
		t.Error("rootCmd seems to have a wrong normalization function")
	}

	// First add the cmdEchoSub to cmdPrint
	cmdPrint.AddCommand(cmdEchoSub)
	if cmdPrint.GlobalNormalizationFunc() != nil && cmdEchoSub.GlobalNormalizationFunc() != nil {
		t.Error("cmdPrint and cmdEchoSub should had no normalization functions")
	}

	// Now add cmdPrint to rootCmd
	rootCmd.AddCommand(cmdPrint)
	if reflect.ValueOf(cmdPrint.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() ||
		reflect.ValueOf(cmdEchoSub.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() {
		t.Error("cmdPrint and cmdEchoSub should had the normalization function of rootCmd")
	}
}

// WordSepNormalizeFunc changes all flags that contain "_" separators
func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
	if strings.Contains(name, "_") {
		return pflag.NormalizedName(strings.Replace(name, "_", "-", -1))
	}
	return pflag.NormalizedName(name)
}

func main() {
	trc := newTmplRendererConfig()

	// flags
	fs := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
	fs.StringVar(&trc.outputPath, "out", trc.outputPath, "")

	fs.SetNormalizeFunc(
		func(f *flag.FlagSet, name string) flag.NormalizedName {
			if strings.Contains(name, "_") {
				return flag.NormalizedName(strings.Replace(name, "_", "-", -1))
			}
			return flag.NormalizedName(name)
		},
	)

	// define usage
	fs.Usage = func() {
		goVersion := strings.TrimPrefix(runtime.Version(), "go")
		fmt.Fprintf(os.Stderr, "%s (version=%s, gitrev=%s, go=%s)\n", cliName, Version, GitRev, goVersion)
		/*
			fmt.Fprintf(os.Stderr, "Usage:\n")
			fs.PrintDefaults()
		*/
	}

	// parse
	fs.Parse(os.Args[1:])

	// set from env (if present)
	fs.VisitAll(func(f *flag.Flag) {
		if !f.Changed {
			key := strings.ToUpper(strings.Join(
				[]string{
					cliName,
					strings.Replace(f.Name, "-", "_", -1),
				},
				"_",
			))
			val := os.Getenv(key)
			if val != "" {
				fs.Set(f.Name, val)
			}
		}
	})

	// check if template was provided
	args := fs.Args()
	if len(args) < 1 {
		log.Fatal("Please provide a template")
	}

	// template file
	tmplFile := args[0]

	// check if file exists
	if _, err := os.Stat(tmplFile); os.IsNotExist(err) {
		log.Fatalf("%s", err)
	}

	// template funcs
	funcMap := make(map[string]interface{})
	funcMap["getenv"] = os.Getenv
	funcMap["getEnv"] = os.Getenv
	funcMap["encodeJSON"] = func(i interface{}) string {
		d, err := json.Marshal(i)
		if err != nil {
			log.Fatalf("%v", err)
		}
		return string(d)
	}
	funcMap["getFileContent"] = func(i string) string {
		d, err := ioutil.ReadFile(i)
		if err != nil {
			log.Fatalf("%v", err)
		}
		return string(d)
	}
	funcMap["getFileContentBytes"] = func(i string) []byte {
		d, err := ioutil.ReadFile(i)
		if err != nil {
			log.Fatalf("%v", err)
		}
		return d
	}
	funcMap["gzip"] = func(i []byte) []byte {
		var b bytes.Buffer
		w := gzip.NewWriter(&b)
		if _, err := w.Write(i); err != nil {
			log.Fatalf("%v", err)
		}

		if err := w.Close(); err != nil {
			log.Fatalf("%v", err)
		}

		return b.Bytes()
	}
	funcMap["encodeBase64"] = func(i []byte) string {
		return base64.StdEncoding.EncodeToString(i)
//.........这里部分代码省略.........