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)
}
success := c.SetCluster(machines)
if !success {
return &Client{c}, errors.New("cannot connect to etcd cluster: " + strings.Join(machines, ","))
}
return &Client{c}, nil
}
func (etcd *ETCDClusterRunner) detectRunningEtcd(index int) bool {
var client *etcdclient.Client
if etcd.serverSSL == nil {
client = etcdclient.NewClient([]string{})
} else {
var err error
client, err = etcdstoreadapter.NewETCDTLSClient(
[]string{etcd.clientURL(index)},
etcd.serverSSL.CertFile,
etcd.serverSSL.KeyFile,
etcd.serverSSL.CAFile,
)
Expect(err).NotTo(HaveOccurred())
}
return client.SetCluster([]string{etcd.clientURL(index)})
}
// NewClient returns an *etcd.Client with a connection to the named machines.
// It will return an error if a connection to the cluster cannot be made.
// The parameter machines needs to be a full URL with schemas.
// e.g. "http://localhost:4001" will work, but "localhost:4001" will not.
func NewClient(machines []string, cert, key, caCert string) (Client, error) {
var c *etcd.Client
var err error
if cert != "" && key != "" {
c, err = etcd.NewTLSClient(machines, cert, key, caCert)
if err != nil {
return nil, err
}
} else {
c = etcd.NewClient(machines)
}
success := c.SetCluster(machines)
if !success {
return nil, fmt.Errorf("cannot connect to the etcd cluster: %s", 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) {
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
}
