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()
}
