From 7bc044ecc2ebb3ac1d789498fbcbdbcdca6f626c Mon Sep 17 00:00:00 2001 From: Bill Farner Date: Tue, 15 Nov 2016 14:47:07 -0800 Subject: [PATCH 1/3] Establish a convention for declaring CLI args Signed-off-by: Bill Farner --- cmd/cli/flavor.go | 108 +++++++++++++++++++++++----------------------- 1 file changed, 53 insertions(+), 55 deletions(-) diff --git a/cmd/cli/flavor.go b/cmd/cli/flavor.go index ab67fec73..f10593239 100644 --- a/cmd/cli/flavor.go +++ b/cmd/cli/flavor.go @@ -18,25 +18,25 @@ import ( func flavorPluginCommand(plugins func() discovery.Plugins) *cobra.Command { - name := "" var flavorPlugin flavor.Plugin cmd := &cobra.Command{ Use: "flavor", Short: "Access flavor plugin", - PersistentPreRunE: func(c *cobra.Command, args []string) error { + } + name := cmd.PersistentFlags().String("name", "", "Name of plugin") - endpoint, err := plugins().Find(name) - if err != nil { - return err - } + cmd.PersistentPreRunE = func(c *cobra.Command, args []string) error { + + endpoint, err := plugins().Find(*name) + if err != nil { + return err + } - flavorPlugin = flavor_plugin.NewClient(endpoint.Address) + flavorPlugin = flavor_plugin.NewClient(endpoint.Address) - return nil - }, + return nil } - cmd.PersistentFlags().StringVar(&name, "name", name, "Name of plugin") logicalIDs := []string{} groupSize := uint(0) @@ -86,6 +86,7 @@ func flavorPluginCommand(plugins func() discovery.Plugins) *cobra.Command { }, } addAllocationMethodFlags(validate) + cmd.AddCommand(validate) prepare := &cobra.Command{ Use: "prepare ", @@ -129,61 +130,58 @@ func flavorPluginCommand(plugins func() discovery.Plugins) *cobra.Command { }, } addAllocationMethodFlags(prepare) + cmd.AddCommand(prepare) - tags := []string{} - id := "" - logicalID := "" healthy := &cobra.Command{ Use: "healthy ", Short: "checks if an instance is considered healthy", - RunE: func(cmd *cobra.Command, args []string) error { - assertNotNil("no plugin", flavorPlugin) - - if len(args) != 1 { - cmd.Usage() - os.Exit(1) - } + } + tags := healthy.Flags().StringSlice("tags", []string{}, "Tags to filter") + id := healthy.Flags().String("id", "", "ID of resource") + logicalID := healthy.Flags().String("logical-id", "", "Logical ID of resource") + healthy.RunE = func(cmd *cobra.Command, args []string) error { + assertNotNil("no plugin", flavorPlugin) + + if len(args) != 1 { + cmd.Usage() + os.Exit(1) + } - flavorProperties, err := ioutil.ReadFile(args[0]) - if err != nil { - log.Error(err) - os.Exit(1) - } + flavorProperties, err := ioutil.ReadFile(args[0]) + if err != nil { + log.Error(err) + os.Exit(1) + } - filter := map[string]string{} - for _, t := range tags { - p := strings.Split(t, "=") - if len(p) == 2 { - filter[p[0]] = p[1] - } else { - filter[p[0]] = "" - } + filter := map[string]string{} + for _, t := range *tags { + p := strings.Split(t, "=") + if len(p) == 2 { + filter[p[0]] = p[1] + } else { + filter[p[0]] = "" } + } - desc := instance.Description{} - if len(filter) > 0 { - desc.Tags = filter - } - if id != "" { - desc.ID = instance.ID(id) - } - if logicalID != "" { - logical := instance.LogicalID(logicalID) - desc.LogicalID = &logical - } + desc := instance.Description{} + if len(filter) > 0 { + desc.Tags = filter + } + if *id != "" { + desc.ID = instance.ID(*id) + } + if *logicalID != "" { + logical := instance.LogicalID(*logicalID) + desc.LogicalID = &logical + } - healthy, err := flavorPlugin.Healthy(json.RawMessage(flavorProperties), desc) - if err == nil { - fmt.Printf("%v\n", healthy) - } - return err - }, + healthy, err := flavorPlugin.Healthy(json.RawMessage(flavorProperties), desc) + if err == nil { + fmt.Printf("%v\n", healthy) + } + return err } - healthy.Flags().StringSliceVar(&tags, "tags", tags, "Tags to filter") - healthy.Flags().StringVar(&id, "id", id, "ID of resource") - healthy.Flags().StringVar(&logicalID, "logical-id", logicalID, "Logical ID of resource") - - cmd.AddCommand(validate, prepare, healthy) + cmd.AddCommand(healthy) return cmd } From 2205e0b6535f2c381da443afc2f8da58128d5080 Mon Sep 17 00:00:00 2001 From: Bill Farner Date: Tue, 15 Nov 2016 15:57:01 -0800 Subject: [PATCH 2/3] Port remaining flags Signed-off-by: Bill Farner --- cmd/cli/group.go | 99 +++++++++++++------------- cmd/cli/instance.go | 86 +++++++++++----------- cmd/cli/main.go | 11 ++- cmd/cli/plugin.go | 33 +++++---- cmd/group/main.go | 56 +++++++-------- cmd/manager/main.go | 39 +++++----- cmd/manager/os.go | 48 ++++++------- cmd/manager/swarm.go | 76 ++++++++++---------- pkg/example/flavor/combo/main.go | 40 +++++------ pkg/example/flavor/swarm/main.go | 53 +++++++------- pkg/example/flavor/vanilla/main.go | 16 ++--- pkg/example/flavor/zookeeper/main.go | 17 ++--- pkg/example/instance/file/main.go | 21 ++---- pkg/example/instance/terraform/main.go | 23 +++--- pkg/example/instance/vagrant/main.go | 44 ++++++------ 15 files changed, 312 insertions(+), 350 deletions(-) diff --git a/cmd/cli/group.go b/cmd/cli/group.go index 3d9e88a72..768feb8ce 100644 --- a/cmd/cli/group.go +++ b/cmd/cli/group.go @@ -22,27 +22,25 @@ const ( func groupPluginCommand(plugins func() discovery.Plugins) *cobra.Command { - name := DefaultGroupPluginName var groupPlugin group.Plugin cmd := &cobra.Command{ Use: "group", Short: "Access group plugin", - PersistentPreRunE: func(c *cobra.Command, args []string) error { + } + name := cmd.PersistentFlags().String("name", DefaultGroupPluginName, "Name of plugin") + cmd.PersistentPreRunE = func(c *cobra.Command, args []string) error { - endpoint, err := plugins().Find(name) - if err != nil { - return err - } + endpoint, err := plugins().Find(*name) + if err != nil { + return err + } - groupPlugin = group_plugin.NewClient(endpoint.Address) + groupPlugin = group_plugin.NewClient(endpoint.Address) - return nil - }, + return nil } - cmd.PersistentFlags().StringVar(&name, "name", name, "Name of plugin") - commit := cobra.Command{ Use: "commit ", Short: "commit a group configuration", @@ -99,44 +97,43 @@ func groupPluginCommand(plugins func() discovery.Plugins) *cobra.Command { }, }) - var quiet bool describe := &cobra.Command{ Use: "describe ", Short: "describe the live instances that make up a group", - RunE: func(cmd *cobra.Command, args []string) error { - assertNotNil("no plugin", groupPlugin) + } + quietDescribe := describe.Flags().BoolP("quiet", "q", false, "Print rows without column headers") + describe.RunE = func(cmd *cobra.Command, args []string) error { + assertNotNil("no plugin", groupPlugin) - if len(args) != 1 { - cmd.Usage() - os.Exit(1) - } + if len(args) != 1 { + cmd.Usage() + os.Exit(1) + } - groupID := group.ID(args[0]) - desc, err := groupPlugin.DescribeGroup(groupID) + groupID := group.ID(args[0]) + desc, err := groupPlugin.DescribeGroup(groupID) - if err == nil { - if !quiet { - fmt.Printf("%-30s\t%-30s\t%-s\n", "ID", "LOGICAL", "TAGS") + if err == nil { + if !*quietDescribe { + fmt.Printf("%-30s\t%-30s\t%-s\n", "ID", "LOGICAL", "TAGS") + } + for _, d := range desc.Instances { + logical := " - " + if d.LogicalID != nil { + logical = string(*d.LogicalID) } - for _, d := range desc.Instances { - logical := " - " - if d.LogicalID != nil { - logical = string(*d.LogicalID) - } - - printTags := []string{} - for k, v := range d.Tags { - printTags = append(printTags, fmt.Sprintf("%s=%s", k, v)) - } - sort.Strings(printTags) - fmt.Printf("%-30s\t%-30s\t%-s\n", d.ID, logical, strings.Join(printTags, ",")) + printTags := []string{} + for k, v := range d.Tags { + printTags = append(printTags, fmt.Sprintf("%s=%s", k, v)) } + sort.Strings(printTags) + + fmt.Printf("%-30s\t%-30s\t%-s\n", d.ID, logical, strings.Join(printTags, ",")) } - return err - }, + } + return err } - describe.Flags().BoolVarP(&quiet, "quiet", "q", false, "Print rows without column headers") cmd.AddCommand(describe) cmd.AddCommand(&cobra.Command{ @@ -198,23 +195,23 @@ func groupPluginCommand(plugins func() discovery.Plugins) *cobra.Command { describeGroups := &cobra.Command{ Use: "ls", Short: "list groups", - RunE: func(cmd *cobra.Command, args []string) error { - assertNotNil("no plugin", groupPlugin) + } + quietls := describe.Flags().BoolP("quiet", "q", false, "Print rows without column headers") + describeGroups.RunE = func(cmd *cobra.Command, args []string) error { + assertNotNil("no plugin", groupPlugin) - groups, err := groupPlugin.InspectGroups() - if err == nil { - if !quiet { - fmt.Printf("%s\n", "ID") - } - for _, g := range groups { - fmt.Printf("%s\n", g.ID) - } + groups, err := groupPlugin.InspectGroups() + if err == nil { + if !*quietls { + fmt.Printf("%s\n", "ID") } + for _, g := range groups { + fmt.Printf("%s\n", g.ID) + } + } - return err - }, + return err } - describeGroups.Flags().BoolVarP(&quiet, "quiet", "q", false, "Print rows without column headers") cmd.AddCommand(describeGroups) return cmd diff --git a/cmd/cli/instance.go b/cmd/cli/instance.go index 49a305add..b971e33bb 100644 --- a/cmd/cli/instance.go +++ b/cmd/cli/instance.go @@ -17,25 +17,24 @@ import ( func instancePluginCommand(plugins func() discovery.Plugins) *cobra.Command { - name := "" var instancePlugin instance.Plugin cmd := &cobra.Command{ Use: "instance", Short: "Access instance plugin", - PersistentPreRunE: func(c *cobra.Command, args []string) error { + } + name := cmd.PersistentFlags().String("name", "", "Name of plugin") + cmd.PersistentPreRunE = func(c *cobra.Command, args []string) error { - endpoint, err := plugins().Find(name) - if err != nil { - return err - } + endpoint, err := plugins().Find(*name) + if err != nil { + return err + } - instancePlugin = instance_plugin.NewClient(endpoint.Address) + instancePlugin = instance_plugin.NewClient(endpoint.Address) - return nil - }, + return nil } - cmd.PersistentFlags().StringVar(&name, "name", name, "Name of plugin") validate := &cobra.Command{ Use: "validate ", @@ -113,52 +112,49 @@ func instancePluginCommand(plugins func() discovery.Plugins) *cobra.Command { }, } - tags := []string{} - var quiet bool describe := &cobra.Command{ Use: "describe", Short: "describe the instances", - RunE: func(cmd *cobra.Command, args []string) error { - assertNotNil("no plugin", instancePlugin) - - filter := map[string]string{} - for _, t := range tags { - p := strings.Split(t, "=") - if len(p) == 2 { - filter[p[0]] = p[1] - } else { - filter[p[0]] = "" - } + } + tags := describe.Flags().StringSlice("tags", []string{}, "Tags to filter") + quiet := describe.Flags().BoolP("quiet", "q", false, "Print rows without column headers") + describe.RunE = func(cmd *cobra.Command, args []string) error { + assertNotNil("no plugin", instancePlugin) + + filter := map[string]string{} + for _, t := range *tags { + p := strings.Split(t, "=") + if len(p) == 2 { + filter[p[0]] = p[1] + } else { + filter[p[0]] = "" } + } - desc, err := instancePlugin.DescribeInstances(filter) - if err == nil { + desc, err := instancePlugin.DescribeInstances(filter) + if err == nil { - if !quiet { - fmt.Printf("%-30s\t%-30s\t%-s\n", "ID", "LOGICAL", "TAGS") + if !*quiet { + fmt.Printf("%-30s\t%-30s\t%-s\n", "ID", "LOGICAL", "TAGS") + } + for _, d := range desc { + logical := " - " + if d.LogicalID != nil { + logical = string(*d.LogicalID) } - for _, d := range desc { - logical := " - " - if d.LogicalID != nil { - logical = string(*d.LogicalID) - } - - printTags := []string{} - for k, v := range d.Tags { - printTags = append(printTags, fmt.Sprintf("%s=%s", k, v)) - } - sort.Strings(printTags) - - fmt.Printf("%-30s\t%-30s\t%-s\n", d.ID, logical, strings.Join(printTags, ",")) + + printTags := []string{} + for k, v := range d.Tags { + printTags = append(printTags, fmt.Sprintf("%s=%s", k, v)) } + sort.Strings(printTags) + + fmt.Printf("%-30s\t%-30s\t%-s\n", d.ID, logical, strings.Join(printTags, ",")) } + } - return err - }, + return err } - describe.Flags().StringSliceVar(&tags, "tags", tags, "Tags to filter") - describe.Flags().BoolVarP(&quiet, "quiet", "q", false, "Print rows without column headers") - cmd.AddCommand(validate, provision, destroy, describe) return cmd diff --git a/cmd/cli/main.go b/cmd/cli/main.go index 562de667e..27efd5e01 100644 --- a/cmd/cli/main.go +++ b/cmd/cli/main.go @@ -14,14 +14,13 @@ import ( func main() { - logLevel := cli.DefaultLogLevel - cmd := &cobra.Command{ Use: os.Args[0], Short: "infrakit cli", - PersistentPreRun: func(c *cobra.Command, args []string) { - cli.SetLogLevel(logLevel) - }, + } + logLevel := cmd.PersistentFlags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + cmd.PersistentPreRun = func(c *cobra.Command, args []string) { + cli.SetLogLevel(*logLevel) } // Don't print usage text for any error returned from a RunE function. Only print it when explicitly requested. @@ -43,8 +42,6 @@ func main() { } cmd.AddCommand(pluginCommand(f), instancePluginCommand(f), groupPluginCommand(f), flavorPluginCommand(f)) - cmd.PersistentFlags().IntVar(&logLevel, "log", logLevel, "Logging level. 0 is least verbose. Max is 5") - err := cmd.Execute() if err != nil { log.Fatal(err) diff --git a/cmd/cli/plugin.go b/cmd/cli/plugin.go index b0bf03d15..ba45609d3 100644 --- a/cmd/cli/plugin.go +++ b/cmd/cli/plugin.go @@ -13,27 +13,26 @@ func pluginCommand(plugins func() discovery.Plugins) *cobra.Command { Short: "Manage plugins", } - var quiet bool ls := cobra.Command{ Use: "ls", Short: "List available plugins", - RunE: func(c *cobra.Command, args []string) error { - entries, err := plugins().List() - if err != nil { - return err - } - - if !quiet { - fmt.Printf("%-20s\t%-s\n", "NAME", "LISTEN") - } - for k, v := range entries { - fmt.Printf("%-20s\t%-s\n", k, v.Address) - } - - return nil - }, } - ls.Flags().BoolVarP(&quiet, "quiet", "q", false, "Print rows without column headers") + quiet := ls.Flags().BoolP("quiet", "q", false, "Print rows without column headers") + ls.RunE = func(c *cobra.Command, args []string) error { + entries, err := plugins().List() + if err != nil { + return err + } + + if !*quiet { + fmt.Printf("%-20s\t%-s\n", "NAME", "LISTEN") + } + for k, v := range entries { + fmt.Printf("%-20s\t%-s\n", k, v.Address) + } + + return nil + } cmd.AddCommand(&ls) diff --git a/cmd/group/main.go b/cmd/group/main.go index 4465f604a..5e8d4eec0 100644 --- a/cmd/group/main.go +++ b/cmd/group/main.go @@ -18,52 +18,46 @@ import ( func main() { - logLevel := cli.DefaultLogLevel - var name string - - pollInterval := 10 * time.Second - cmd := &cobra.Command{ Use: os.Args[0], Short: "Group server", - RunE: func(c *cobra.Command, args []string) error { + } + name := cmd.Flags().String("name", "group", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + pollInterval := cmd.Flags().Duration("poll-interval", 10*time.Second, "Group polling interval") + cmd.RunE = func(c *cobra.Command, args []string) error { - cli.SetLogLevel(logLevel) + cli.SetLogLevel(*logLevel) - plugins, err := discovery.NewPluginDiscovery() - if err != nil { - return err - } + plugins, err := discovery.NewPluginDiscovery() + if err != nil { + return err + } - instancePluginLookup := func(n string) (instance.Plugin, error) { - endpoint, err := plugins.Find(n) - if err != nil { - return nil, err - } - return instance_client.NewClient(endpoint.Address), nil + instancePluginLookup := func(n string) (instance.Plugin, error) { + endpoint, err := plugins.Find(n) + if err != nil { + return nil, err } + return instance_client.NewClient(endpoint.Address), nil + } - flavorPluginLookup := func(n string) (flavor.Plugin, error) { - endpoint, err := plugins.Find(n) - if err != nil { - return nil, err - } - return flavor_client.NewClient(endpoint.Address), nil + flavorPluginLookup := func(n string) (flavor.Plugin, error) { + endpoint, err := plugins.Find(n) + if err != nil { + return nil, err } + return flavor_client.NewClient(endpoint.Address), nil + } - cli.RunPlugin(name, group_server.PluginServer( - group.NewGroupPlugin(instancePluginLookup, flavorPluginLookup, pollInterval))) + cli.RunPlugin(*name, group_server.PluginServer( + group.NewGroupPlugin(instancePluginLookup, flavorPluginLookup, *pollInterval))) - return nil - }, + return nil } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().StringVar(&name, "name", "group", "Plugin name to advertise for discovery") - cmd.Flags().IntVar(&logLevel, "log", logLevel, "Logging level. 0 is least verbose. Max is 5") - cmd.Flags().DurationVar(&pollInterval, "poll-interval", pollInterval, "Group polling interval") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/cmd/manager/main.go b/cmd/manager/main.go index 2481340f6..88c1c2fab 100644 --- a/cmd/manager/main.go +++ b/cmd/manager/main.go @@ -14,7 +14,7 @@ import ( "github.com/spf13/cobra" ) -type backend struct { +type config struct { id string plugins discovery.Plugins leader leader.Detector @@ -24,21 +24,29 @@ type backend struct { func main() { - logLevel := cli.DefaultLogLevel - backend := &backend{} - cmd := &cobra.Command{ Use: filepath.Base(os.Args[0]), Short: "Manager", - PersistentPreRun: func(c *cobra.Command, args []string) { - cli.SetLogLevel(logLevel) - }, } - cmd.PersistentFlags().IntVar(&logLevel, "log", logLevel, "Logging level. 0 is least verbose. Max is 5") - cmd.PersistentFlags().StringVar(&backend.id, "name", "group", "Name of the manager") - cmd.PersistentFlags().StringVar(&backend.pluginName, "proxy-for-group", "group-stateless", "Name of the group plugin to proxy for.") - cmd.AddCommand(cli.VersionCommand(), osEnvironment(backend), swarmEnvironment(backend)) + logLevel := cmd.PersistentFlags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + pluginName := cmd.PersistentFlags().String("name", "group", "Name of the manager") + backendPlugin := cmd.PersistentFlags().String( + "proxy-for-group", + "group-stateless", + "Name of the group plugin to proxy for.") + cmd.PersistentPreRun = func(c *cobra.Command, args []string) { + cli.SetLogLevel(*logLevel) + } + + buildConfig := func() config { + return config{ + id: *pluginName, + pluginName: *backendPlugin, + } + } + + cmd.AddCommand(cli.VersionCommand(), osEnvironment(buildConfig), swarmEnvironment(buildConfig)) err := cmd.Execute() if err != nil { @@ -47,12 +55,11 @@ func main() { } } -func runMain(backend *backend) error { +func runMain(cfg config) error { - log.Infoln("Starting up manager:", backend) + log.Infoln("Starting up manager:", cfg) - mgr, err := manager.NewManager(backend.plugins, - backend.leader, backend.snapshot, backend.pluginName) + mgr, err := manager.NewManager(cfg.plugins, cfg.leader, cfg.snapshot, cfg.pluginName) if err != nil { return err } @@ -62,7 +69,7 @@ func runMain(backend *backend) error { return err } - cli.RunPlugin(backend.id, group_rpc.PluginServer(mgr)) + cli.RunPlugin(cfg.id, group_rpc.PluginServer(mgr)) mgr.Stop() log.Infoln("Manager stopped") diff --git a/cmd/manager/os.go b/cmd/manager/os.go index 3f295b7fe..30e1b4c94 100644 --- a/cmd/manager/os.go +++ b/cmd/manager/os.go @@ -41,40 +41,38 @@ func defaultStoreDir() string { return filepath.Join(getHome(), ".infrakit/configs") } -func osEnvironment(backend *backend) *cobra.Command { - - var pollInterval time.Duration - var filename, storeDir string +func osEnvironment(getConfig func() config) *cobra.Command { cmd := &cobra.Command{ Use: "os", Short: "os", - RunE: func(c *cobra.Command, args []string) error { + } + leaderFile := cmd.Flags().String("leader-file", defaultLeaderFile(), "File used for leader election/detection") + storeDir := cmd.Flags().String("store-dir", defaultStoreDir(), "Dir to store the config") + pollInterval := cmd.Flags().Duration("poll-interval", 5*time.Second, "Leader polling interval") + cmd.RunE = func(c *cobra.Command, args []string) error { - plugins, err := discovery.NewPluginDiscovery() - if err != nil { - return err - } + plugins, err := discovery.NewPluginDiscovery() + if err != nil { + return err + } - leader, err := file_leader.NewDetector(pollInterval, filename, backend.id) - if err != nil { - return err - } + cfg := getConfig() + leader, err := file_leader.NewDetector(*pollInterval, *leaderFile, cfg.id) + if err != nil { + return err + } - snapshot, err := file_store.NewSnapshot(storeDir, "global.config") - if err != nil { - return err - } + snapshot, err := file_store.NewSnapshot(*storeDir, "global.config") + if err != nil { + return err + } - backend.plugins = plugins - backend.leader = leader - backend.snapshot = snapshot + cfg.plugins = plugins + cfg.leader = leader + cfg.snapshot = snapshot - return runMain(backend) - }, + return runMain(cfg) } - cmd.Flags().StringVar(&filename, "leader-file", defaultLeaderFile(), "File used for leader election/detection") - cmd.Flags().StringVar(&storeDir, "store-dir", defaultStoreDir(), "Dir to store the config") - cmd.Flags().DurationVar(&pollInterval, "poll-interval", 5*time.Second, "Leader polling interval") return cmd } diff --git a/cmd/manager/swarm.go b/cmd/manager/swarm.go index 5f329f1aa..2b036882b 100644 --- a/cmd/manager/swarm.go +++ b/cmd/manager/swarm.go @@ -12,49 +12,49 @@ import ( "github.com/spf13/cobra" ) -func swarmEnvironment(backend *backend) *cobra.Command { - - tlsOptions := tlsconfig.Options{} - host := "unix:///var/run/docker.sock" - - var pollInterval time.Duration +func swarmEnvironment(getConfig func() config) *cobra.Command { cmd := &cobra.Command{ Use: "swarm", Short: "swarm mode for leader detection and storage", - RunE: func(c *cobra.Command, args []string) error { - - dockerClient, err := docker.NewDockerClient(host, &tlsOptions) - log.Infoln("Connect to docker", host, "err=", err) - if err != nil { - return err - } - - leader := swarm_leader.NewDetector(pollInterval, dockerClient) - snapshot, err := swarm_store.NewSnapshot(dockerClient) - if err != nil { - return err - } - - plugins, err := discovery.NewPluginDiscovery() - if err != nil { - return err - } - - backend.plugins = plugins - backend.leader = leader - backend.snapshot = snapshot - - return runMain(backend) - }, } - - cmd.Flags().DurationVar(&pollInterval, "poll-interval", 5*time.Second, "Leader polling interval") - cmd.Flags().StringVar(&host, "host", host, "Docker host") - cmd.Flags().StringVar(&tlsOptions.CAFile, "tlscacert", "", "TLS CA cert file path") - cmd.Flags().StringVar(&tlsOptions.CertFile, "tlscert", "", "TLS cert file path") - cmd.Flags().StringVar(&tlsOptions.KeyFile, "tlskey", "", "TLS key file path") - cmd.Flags().BoolVar(&tlsOptions.InsecureSkipVerify, "tlsverify", true, "True to skip TLS") + pollInterval := cmd.Flags().Duration("poll-interval", 5*time.Second, "Leader polling interval") + host := cmd.Flags().String("host", "unix:///var/run/docker.sock", "Docker host") + caFile := cmd.Flags().String("tlscacert", "", "TLS CA cert file path") + certFile := cmd.Flags().String("tlscert", "", "TLS cert file path") + tlsKey := cmd.Flags().String("tlskey", "", "TLS key file path") + insecureSkipVerify := cmd.Flags().Bool("tlsverify", true, "True to skip TLS") + cmd.RunE = func(c *cobra.Command, args []string) error { + + dockerClient, err := docker.NewDockerClient(*host, &tlsconfig.Options{ + CAFile: *caFile, + CertFile: *certFile, + KeyFile: *tlsKey, + InsecureSkipVerify: *insecureSkipVerify, + }) + log.Infoln("Connect to docker", host, "err=", err) + if err != nil { + return err + } + + leader := swarm_leader.NewDetector(*pollInterval, dockerClient) + snapshot, err := swarm_store.NewSnapshot(dockerClient) + if err != nil { + return err + } + + plugins, err := discovery.NewPluginDiscovery() + if err != nil { + return err + } + + cfg := getConfig() + cfg.plugins = plugins + cfg.leader = leader + cfg.snapshot = snapshot + + return runMain(cfg) + } return cmd } diff --git a/pkg/example/flavor/combo/main.go b/pkg/example/flavor/combo/main.go index c71e01dd4..159436127 100644 --- a/pkg/example/flavor/combo/main.go +++ b/pkg/example/flavor/combo/main.go @@ -13,38 +13,34 @@ import ( func main() { - var logLevel int - var name string - cmd := &cobra.Command{ Use: os.Args[0], Short: "A Flavor plugin that supports composition of other Flavors", - Run: func(c *cobra.Command, args []string) { - - plugins, err := discovery.NewPluginDiscovery() + } + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + name := cmd.Flags().String("name", "flavor-combo", "Plugin name to advertise for discovery") + cmd.Run = func(c *cobra.Command, args []string) { + + plugins, err := discovery.NewPluginDiscovery() + if err != nil { + log.Error(err) + os.Exit(1) + } + + flavorPluginLookup := func(n string) (flavor.Plugin, error) { + endpoint, err := plugins.Find(n) if err != nil { - log.Error(err) - os.Exit(1) + return nil, err } + return flavor_rpc.NewClient(endpoint.Address), nil + } - flavorPluginLookup := func(n string) (flavor.Plugin, error) { - endpoint, err := plugins.Find(n) - if err != nil { - return nil, err - } - return flavor_rpc.NewClient(endpoint.Address), nil - } - - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, flavor_rpc.PluginServer(NewPlugin(flavorPluginLookup))) - }, + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, flavor_rpc.PluginServer(NewPlugin(flavorPluginLookup))) } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") - cmd.Flags().StringVar(&name, "name", "flavor-combo", "Plugin name to advertise for discovery") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/flavor/swarm/main.go b/pkg/example/flavor/swarm/main.go index d5020c5b4..5cc446832 100644 --- a/pkg/example/flavor/swarm/main.go +++ b/pkg/example/flavor/swarm/main.go @@ -14,41 +14,38 @@ import ( func main() { - var logLevel int - var name string - - tlsOptions := tlsconfig.Options{} - host := "unix:///var/run/docker.sock" - cmd := &cobra.Command{ Use: os.Args[0], Short: "Docker Swarm flavor plugin", - Run: func(c *cobra.Command, args []string) { - - cli.SetLogLevel(logLevel) - - dockerClient, err := docker.NewDockerClient(host, &tlsOptions) - log.Infoln("Connect to docker", host, "err=", err) - if err != nil { - log.Error(err) - os.Exit(1) - } - - cli.RunPlugin(name, flavor_plugin.PluginServer(swarm.NewSwarmFlavor(dockerClient))) - }, + } + name := cmd.Flags().String("name", "flavor-swarm", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + host := cmd.Flags().String("host", "unix:///var/run/docker.sock", "Docker host") + caFile := cmd.Flags().String("tlscacert", "", "TLS CA cert file path") + certFile := cmd.Flags().String("tlscert", "", "TLS cert file path") + tlsKey := cmd.Flags().String("tlskey", "", "TLS key file path") + insecureSkipVerify := cmd.Flags().Bool("tlsverify", true, "True to skip TLS") + cmd.RunE = func(c *cobra.Command, args []string) error { + + cli.SetLogLevel(*logLevel) + + dockerClient, err := docker.NewDockerClient(*host, &tlsconfig.Options{ + CAFile: *caFile, + CertFile: *certFile, + KeyFile: *tlsKey, + InsecureSkipVerify: *insecureSkipVerify, + }) + log.Infoln("Connect to docker", host, "err=", err) + if err != nil { + return err + } + + cli.RunPlugin(*name, flavor_plugin.PluginServer(swarm.NewSwarmFlavor(dockerClient))) + return nil } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().StringVar(&name, "name", "flavor-swarm", "Plugin name to advertise for discovery") - cmd.PersistentFlags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") - - cmd.PersistentFlags().StringVar(&host, "host", host, "Docker host") - cmd.PersistentFlags().StringVar(&tlsOptions.CAFile, "tlscacert", "", "TLS CA cert file path") - cmd.PersistentFlags().StringVar(&tlsOptions.CertFile, "tlscert", "", "TLS cert file path") - cmd.PersistentFlags().StringVar(&tlsOptions.KeyFile, "tlskey", "", "TLS key file path") - cmd.PersistentFlags().BoolVar(&tlsOptions.InsecureSkipVerify, "tlsverify", true, "True to skip TLS") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/flavor/vanilla/main.go b/pkg/example/flavor/vanilla/main.go index e148893ca..31e53c0ad 100644 --- a/pkg/example/flavor/vanilla/main.go +++ b/pkg/example/flavor/vanilla/main.go @@ -12,23 +12,19 @@ import ( func main() { - logLevel := cli.DefaultLogLevel - var name string - cmd := &cobra.Command{ Use: os.Args[0], Short: "Vanilla flavor plugin", - Run: func(c *cobra.Command, args []string) { - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, flavor_plugin.PluginServer(vanilla.NewPlugin())) - }, + } + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + name := cmd.Flags().String("name", "flavor-vanilla", "Plugin name to advertise for discovery") + cmd.Run = func(c *cobra.Command, args []string) { + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, flavor_plugin.PluginServer(vanilla.NewPlugin())) } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().IntVar(&logLevel, "log", logLevel, "Logging level. 0 is least verbose. Max is 5") - cmd.Flags().StringVar(&name, "name", "flavor-vanilla", "Plugin name to advertise for discovery") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/flavor/zookeeper/main.go b/pkg/example/flavor/zookeeper/main.go index bf0175d37..1ef762ebc 100644 --- a/pkg/example/flavor/zookeeper/main.go +++ b/pkg/example/flavor/zookeeper/main.go @@ -12,24 +12,19 @@ import ( func main() { - var logLevel int - var name string - cmd := &cobra.Command{ Use: os.Args[0], Short: "Zookeeper flavor plugin", - Run: func(c *cobra.Command, args []string) { - - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, flavor_plugin.PluginServer(zk.NewPlugin())) - }, + } + name := cmd.Flags().String("name", "flavor-zookeeper", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + cmd.Run = func(c *cobra.Command, args []string) { + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, flavor_plugin.PluginServer(zk.NewPlugin())) } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().StringVar(&name, "name", "flavor-zookeeper", "Plugin name to advertise for discovery") - cmd.PersistentFlags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/instance/file/main.go b/pkg/example/instance/file/main.go index fcc55cea5..013c1204d 100644 --- a/pkg/example/instance/file/main.go +++ b/pkg/example/instance/file/main.go @@ -11,27 +11,20 @@ import ( func main() { - var logLevel int - var name string - var dir string - cmd := &cobra.Command{ Use: os.Args[0], Short: "File instance plugin", - Run: func(c *cobra.Command, args []string) { - - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, instance_plugin.PluginServer(NewFileInstancePlugin(dir))) - }, + } + name := cmd.Flags().String("name", "instance-file", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + dir := cmd.Flags().String("dir", os.TempDir(), "Dir for storing the files") + cmd.Run = func(c *cobra.Command, args []string) { + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, instance_plugin.PluginServer(NewFileInstancePlugin(*dir))) } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().StringVar(&name, "name", "instance-file", "Plugin name to advertise for discovery") - cmd.PersistentFlags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") - - cmd.Flags().StringVar(&dir, "dir", os.TempDir(), "Dir for storing the files") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/instance/terraform/main.go b/pkg/example/instance/terraform/main.go index be4711a0c..9a99d44db 100644 --- a/pkg/example/instance/terraform/main.go +++ b/pkg/example/instance/terraform/main.go @@ -20,27 +20,22 @@ func mustHaveTerraform() { func main() { - mustHaveTerraform() - - var name string - var logLevel int - var dir string - cmd := &cobra.Command{ Use: os.Args[0], Short: "Terraform instance plugin", - Run: func(c *cobra.Command, args []string) { - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, instance_plugin.PluginServer(NewTerraformInstancePlugin(dir))) - }, + } + name := cmd.Flags().String("name", "instance-terraform", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + dir := cmd.Flags().String("dir", os.TempDir(), "Dir for storing plan files") + cmd.Run = func(c *cobra.Command, args []string) { + mustHaveTerraform() + + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, instance_plugin.PluginServer(NewTerraformInstancePlugin(*dir))) } cmd.AddCommand(cli.VersionCommand()) - cmd.Flags().StringVar(&name, "name", "instance-terraform", "Plugin name to advertise for discovery") - cmd.PersistentFlags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") - cmd.Flags().StringVar(&dir, "dir", os.TempDir(), "Dir for storing plan files") - err := cmd.Execute() if err != nil { log.Error(err) diff --git a/pkg/example/instance/vagrant/main.go b/pkg/example/instance/vagrant/main.go index e3cb4bc1a..a504a5b2d 100644 --- a/pkg/example/instance/vagrant/main.go +++ b/pkg/example/instance/vagrant/main.go @@ -13,36 +13,38 @@ import ( func main() { - var name string - var logLevel int - var dir string - var templFile string - cmd := &cobra.Command{ Use: os.Args[0], Short: "Vagrant instance plugin", - Run: func(c *cobra.Command, args []string) { - templ := template.Must(template.New("").Parse(vagrant.VagrantFile)) - if _, err := os.Stat(templFile); err == nil { - templ = template.Must(template.ParseFiles(templFile)) - } - - cli.SetLogLevel(logLevel) - cli.RunPlugin(name, instance_plugin.PluginServer(vagrant.NewVagrantPlugin(dir, templ))) - }, } - - cmd.AddCommand(cli.VersionCommand()) - - cmd.Flags().StringVar(&name, "name", "instance-vagrant", "Plugin name to advertise for discovery") - cmd.PersistentFlags().IntVar(&logLevel, "log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") + name := cmd.Flags().String("name", "instance-vagrant", "Plugin name to advertise for discovery") + logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5") defaultDir, err := os.Getwd() if err != nil { log.Error(err) os.Exit(1) } - cmd.Flags().StringVar(&dir, "dir", defaultDir, "Vagrant directory") - cmd.Flags().StringVar(&templFile, "template", templFile, "Vagrant Template file") + dir := cmd.Flags().String("dir", defaultDir, "Vagrant directory") + templFile := cmd.Flags().String("template", "", "Vagrant Template file") + cmd.RunE = func(c *cobra.Command, args []string) error { + + var templ *template.Template + if *templFile == "" { + templ = template.Must(template.New("").Parse(vagrant.VagrantFile)) + } else { + var err error + templ, err = template.ParseFiles() + if err != nil { + return err + } + } + + cli.SetLogLevel(*logLevel) + cli.RunPlugin(*name, instance_plugin.PluginServer(vagrant.NewVagrantPlugin(*dir, templ))) + return nil + } + + cmd.AddCommand(cli.VersionCommand()) if err := cmd.Execute(); err != nil { log.Error(err) From 48ad8650b740018909e4ef96f96885f5175b6dd8 Mon Sep 17 00:00:00 2001 From: Bill Farner Date: Tue, 15 Nov 2016 16:09:17 -0800 Subject: [PATCH 3/3] Fix copy-paste error Signed-off-by: Bill Farner --- cmd/cli/group.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/cli/group.go b/cmd/cli/group.go index 768feb8ce..1e61cdf8b 100644 --- a/cmd/cli/group.go +++ b/cmd/cli/group.go @@ -196,7 +196,7 @@ func groupPluginCommand(plugins func() discovery.Plugins) *cobra.Command { Use: "ls", Short: "list groups", } - quietls := describe.Flags().BoolP("quiet", "q", false, "Print rows without column headers") + quietls := describeGroups.Flags().BoolP("quiet", "q", false, "Print rows without column headers") describeGroups.RunE = func(cmd *cobra.Command, args []string) error { assertNotNil("no plugin", groupPlugin)