Golang Client.SetDialTimeout方法代码示例

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