func NewDockerProxy(tlsConfig string) (*DockerProxy, error) {
tlsFlagset := flag.NewFlagSet("tls-docker-machine", flag.ExitOnError)
flTlsVerify := tlsFlagset.Bool("tlsverify", false, "Use TLS and verify the remote")
flCa := tlsFlagset.String("tlscacert", "", "Trust certs signed only by this CA")
flCert := tlsFlagset.String("tlscert", "", "Path to TLS certificate file")
flKey := tlsFlagset.String("tlskey", "", "Path to TLS key file")
host := tlsFlagset.String("H", "", "docker daemon host")
err := tlsFlagset.Parse(strings.Split(tlsConfig, " "))
if err != nil {
fmt.Errorf("Fail to parse machine config, data: %s, error: %s", tlsConfig, err.Error())
return nil, err
}
config, err := loadTLSConfig(normalizeString(*flCa), normalizeString(*flCert), normalizeString(*flKey), *flTlsVerify)
if err != nil {
fmt.Errorf("Fail to load tls config, error: %s", err.Error())
return nil, err
}
client, err := dockerclient.NewDockerClientTimeout(*host, config, time.Duration(requestTimeout*time.Second))
if err != nil {
fmt.Errorf("Fail to build a docker client to %s, error: %s", *host, err.Error())
return nil, err
}
return &DockerProxy{client}, nil
}
func newDockerStressor(context *cli.Context) (ds *dockerStressor, err error) {
ds = &dockerStressor{}
client, err := dcli.NewDockerClientTimeout(
"unix:///var/run/docker.sock", nil, time.Second*5)
if err != nil {
return
}
ds.dockerClient = client
scfg, err := loadStressCfg(context.String("config"))
if err != nil {
return
}
ds.stressConfig = scfg
if context.Int("count") <= 0 {
return nil, errors.New("flag count must > 0")
}
ds.containerNum = context.Int("count")
if context.Int("concurrent") <= 0 {
return nil, errors.New("flag concurrent must > 0")
}
ds.containerConCurrent = context.Int("concurrent")
ds.containerRunTime = context.Duration("runtime")
return
}
// Connect will initialize a connection to the Docker daemon running on the
// host, gather machine specs (memory, cpu, ...) and monitor state changes.
func (n *Node) Connect(config *tls.Config) error {
c, err := dockerclient.NewDockerClientTimeout(n.Addr, config, time.Duration(requestTimeout))
if err != nil {
return err
}
addr, err := net.ResolveIPAddr("ip4", strings.Split(c.URL.Host, ":")[0])
if err != nil {
return err
}
n.IP = addr.IP.String()
return n.connectClient(c)
}
// Connect will initialize a connection to the Docker daemon running on the
// host, gather machine specs (memory, cpu, ...) and monitor state changes.
func (e *Engine) Connect(config *tls.Config) error {
host, _, err := net.SplitHostPort(e.Addr)
if err != nil {
return err
}
addr, err := net.ResolveIPAddr("ip4", host)
if err != nil {
return err
}
e.IP = addr.IP.String()
c, err := dockerclient.NewDockerClientTimeout("tcp://"+e.Addr, config, time.Duration(requestTimeout))
if err != nil {
return err
}
return e.ConnectWithClient(c)
}
// Connect will initialize a connection to the Docker daemon running on the
// host, gather machine specs (memory, cpu, ...) and monitor state changes.
func (n *node) connect(config *tls.Config) error {
host, _, err := net.SplitHostPort(n.addr)
if err != nil {
return err
}
addr, err := net.ResolveIPAddr("ip4", host)
if err != nil {
return err
}
n.ip = addr.IP.String()
c, err := dockerclient.NewDockerClientTimeout("tcp://"+n.addr, config, time.Duration(requestTimeout))
if err != nil {
return err
}
return n.connectClient(c)
}
func waitForDockerDaemons(wait int, nodes []string) []string {
var maxDockerPingAttemps int = wait/SecondsBetweenDockerPings + 1
log.Infof("[bootstrap] Trying to reach docker daemons in %v attempts.", maxDockerPingAttemps)
var nodesFound []string
for i := 0; ; i++ {
if i >= maxDockerPingAttemps {
log.Infof("[bootstrap] Max attempts were reached, %v docker daemons are available.", len(nodesFound))
return nodesFound
}
if len(nodesFound) == len(nodes) {
log.Infof("[bootstrap] All docker daemons are available.")
return nodesFound
}
time.Sleep(SecondsBetweenDockerPings * time.Second)
log.Debugf("[bootstrap] Ping docker daemons, attempt %v", i+1)
var wg sync.WaitGroup
for _, node := range nodes {
wg.Add(1)
go func(node string) {
defer wg.Done()
time.Sleep(1 * time.Second)
if contains(nodesFound, node) {
log.Debugf("[bootstrap] Docker daemon on node %s has already responded, not pinging it again.", node)
return
}
client, err := docker.NewDockerClientTimeout("http://"+node, nil, time.Duration(5*time.Second))
if err != nil {
log.Debugf("[bootstrap] Couldn't create client for docker daemon (%s): %s", node, err)
return
}
if _, err := client.Info(); err != nil {
log.Debugf("[bootstrap] Failed to retrieve info from docker daemon (%s): %s", node, err)
} else {
log.Debugf("[bootstrap] Docker daemon responded on node %s.", node)
nodesFound = append(nodesFound, node)
}
}(node)
}
wg.Wait()
log.Infof("[bootstrap] Attempt %v: %v docker daemons are available.", i+1, len(nodesFound))
}
}
// Connect will initialize a connection to the Docker daemon running on the
// host, gather machine specs (memory, cpu, ...) and monitor state changes.
func (e *Engine) Connect(config *tls.Config) error {
host, _, err := net.SplitHostPort(e.Addr)
if err != nil {
return err
}
addr, err := net.ResolveIPAddr("ip4", host)
if err != nil {
return err
}
e.IP = addr.IP.String()
c, err := dockerclient.NewDockerClientTimeout("tcp://"+e.Addr, config, time.Duration(requestTimeout), setTCPUserTimeout)
if err != nil {
return err
}
// Use HTTP Client used by dockerclient to create engine-api client
apiClient, err := engineapi.NewClient("tcp://"+e.Addr, "", c.HTTPClient, nil)
if err != nil {
return err
}
return e.ConnectWithClient(c, apiClient)
}