func NewEtcdClient(addr string, dialTimeout time.Duration) (*EtcdClient, error) { var c *api.Client /* var err error if cert != "" && key != "" { c, err = etcd.NewTLSClient(machines, cert, key, caCert) if err != nil { return &Client{c}, err } } else { c = etcd.NewClient(machines) } */ // machine addresses machines := []string{addr} // create custom client c = api.NewClient(machines) if !c.SetCluster(machines) { return nil, errors.New("cannot connect to etcd cluster: " + addr) } // configure dial timeout c.SetDialTimeout(dialTimeout) return &EtcdClient{addr: addr, client: c}, nil }
// NewEtcdClient returns an *etcd.Client with a connection to named machines. // It returns an error if a connection to the cluster cannot be made. func NewEtcdClient(machines []string, cert, key string, caCert string) (*Client, error) { var c *goetcd.Client var err error if cert != "" && key != "" { c, err = goetcd.NewTLSClient(machines, cert, key, caCert) if err != nil { return &Client{c}, err } } else { c = goetcd.NewClient(machines) } // Configure the DialTimeout, since 1 second is often too short c.SetDialTimeout(time.Duration(3) * time.Second) maxConnectAttempts := 10 for attempt := 1; attempt <= maxConnectAttempts; attempt++ { success := c.SetCluster(machines) if success { break return &Client{c}, nil } if attempt == maxConnectAttempts { break return &Client{c}, errors.New("cannot connect to etcd cluster: " + strings.Join(machines, ",")) } log.Info(fmt.Sprintf("[Attempt: %d] Attempting access to etcd after 5 second sleep", attempt)) time.Sleep(5 * time.Second) } return &Client{c}, nil }
// NewEtcdClient returns an *etcd.Client with a connection to named machines. // It returns an error if a connection to the cluster cannot be made. func NewEtcdClient(machines []string, cert, key string, caCert string) (*Client, error) { var c *etcd.Client if cert != "" && key != "" { c, err := etcd.NewTLSClient(machines, cert, key, caCert) if err != nil { return &Client{c}, err } } else { c = etcd.NewClient(machines) } // Configure the DialTimeout, since 1 second is often too short c.SetDialTimeout(time.Duration(3) * time.Second) success := c.SetCluster(machines) if !success { return &Client{c}, errors.New("cannot connect to etcd cluster: " + strings.Join(machines, ",")) } return &Client{c}, nil }
// NewEtcdClient returns an *etcd.Client with a connection to named machines. // It returns an error if a connection to the cluster cannot be made. //func NewEtcdClient(machines []string, cert, key string, caCert string) (*Client, error) { func NewEtcdClient(machines []string, cert, key string, caCert string, basicAuth bool, username string, password string) (*Client, error) { var c *goetcd.Client var err error if cert != "" && key != "" { c, err = goetcd.NewTLSClient(machines, cert, key, caCert) if err != nil { return &Client{c}, err } } else { c = goetcd.NewClient(machines) } if basicAuth { c.SetCredentials(username, password) } // Configure the DialTimeout, since 1 second is often too short c.SetDialTimeout(time.Duration(3) * time.Second) success := c.SetCluster(machines) if !success { return &Client{c}, errors.New("cannot connect to etcd cluster: " + strings.Join(machines, ",")) } return &Client{c}, nil }
// NewEtcdClient returns an *etcd.Client with a connection to named machines. // It returns an error if a connection to the cluster cannot be made. func NewEtcdClient(machines []string, cert, key string, caCert string, noDiscover bool) (*Client, error) { var c *goetcd.Client var err error machines = prependSchemeToMachines(machines) if cert != "" && key != "" { c, err = goetcd.NewTLSClient(machines, cert, key, caCert) if err != nil { return &Client{c}, err } } else { c = goetcd.NewClient(machines) } // Configure the DialTimeout, since 1 second is often too short c.SetDialTimeout(time.Duration(3) * time.Second) // If noDiscover is not set, we should locate the whole etcd cluster. if !noDiscover { success := c.SetCluster(machines) if !success { return &Client{c}, errors.New("cannot connect to etcd cluster: " + strings.Join(machines, ",")) } } return &Client{c}, nil }
func main() { var ( nodes string taskList string tasks []string confPath string confData *lib.RunConfig cliVars string cliData map[string]interface{} verbose bool taskDir string tmplDir string etcdClient *etcd.Client base *cobra.Command err error ) base = &cobra.Command{ Use: "atom", Short: "atom", Long: "atom", Run: func(cmd *cobra.Command, args []string) { confData, err = lib.ParseAtomConfig(confPath) if err != nil { log.Printf("Config read error: %s", err) if (taskDir == "") || (tmplDir == "") { return } else { confData = &lib.RunConfig{ TaskDir: taskDir, TmplDir: tmplDir, Verbose: verbose, } } } if err := yaml.Unmarshal([]byte(cliVars), &cliData); err != nil { log.Printf("Error: %s", err) } if nodes == "" { etcdClient = nil } else { etcdClient = etcd.NewClient([]string{nodes}) etcdClient.SetDialTimeout(time.Duration(3) * time.Second) if !etcdClient.SyncCluster() { log.Fatal("Couldn't sync with etcd cluster.") } etcdClient.SetConsistency(etcd.STRONG_CONSISTENCY) } for _, name := range strings.Split(taskList, ",") { if name == "" { continue } tasks = append(tasks, name) } if len(tasks) <= 0 { tasks = nil } atom := lib.NewAtom(confData, &cliData, etcdClient) atom.Run(tasks...) }, } base.Flags().StringVarP(&taskList, "run", "r", "", "tasks to run") base.PersistentFlags().StringVarP(&cliVars, "data", "d", "", "cli data (string, yaml)") base.PersistentFlags().StringVarP(&confPath, "conf", "c", "/etc/atom/atom.yml", "atom.yml") base.PersistentFlags().StringVarP(&nodes, "nodes", "n", "", "etcd nodes") base.PersistentFlags().StringVarP(&taskDir, "task", "t", "", "task directory") base.PersistentFlags().StringVarP(&tmplDir, "template", "m", "", "template directory") base.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose") base.Execute() }