// 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)
}
funcMap["toInt"] = func(s string) int {
i, err := strconv.Atoi(s)
if err != nil {
log.Fatalf("%v", err)
}
return i
}
funcMap["add"] = func(a, b int) int {
return a + b
}
funcMap["sub"] = func(a, b int) int {
return a - b
}
// create template
tmpl, err := template.New(path.Base(tmplFile)).Funcs(funcMap).ParseFiles(tmplFile)
if err != nil {
log.Fatalf("Unable to process template %s, %s", tmplFile, err)
}
// choose writer between file and stdout
var writer io.Writer
if trc.outputPath != "" {
f, err := os.Create(trc.outputPath)
if err != nil {
log.Fatalf("Unable to create %s: %v", trc.outputPath, err)
}
defer f.Close()
writer = f
} else {
writer = os.Stdout
}
// and then execute ;)
if err = tmpl.Execute(writer, nil); err != nil {
log.Fatalf("%s", err)
}
}