func setupAppConfig(f *clientcmd.Factory, c *cobra.Command, args []string, config *newcmd.AppConfig) error { namespace, _, err := f.DefaultNamespace() if err != nil { return err } dockerClient, _, err := dockerutil.NewHelper().GetClient() if err == nil { if err = dockerClient.Ping(); err == nil { config.SetDockerClient(dockerClient) } } if err != nil { glog.V(2).Infof("No local Docker daemon detected: %v", err) } osclient, _, err := f.Clients() if err != nil { return err } config.SetOpenShiftClient(osclient, namespace) unknown := config.AddArguments(args) if len(unknown) != 0 { return cmdutil.UsageError(c, "Did not recognize the following arguments: %v", unknown) } return nil }
func NewCommandStartAllInOne(name string) *cobra.Command { dockerHelper := docker.NewHelper() cfg := &config{Docker: *dockerHelper} cmd := &cobra.Command{ Use: name, Short: "Launch in all-in-one mode", Run: func(c *cobra.Command, args []string) { cfg.masterHost = env("OPENSHIFT_MASTER", "127.0.0.1") cfg.bindAddr = env("OPENSHIFT_BIND_ADDR", "127.0.0.1") cfg.nodeHosts = []string{"127.0.0.1"} if len(os.Getenv("OPENSHIFT_MASTER")) > 0 { if cfg.masterHost == cfg.bindAddr { cfg.nodeHosts = []string{} cfg.ListenAddr = cfg.masterHost + ":8080" glog.Infof("Starting master with cfg %v", cfg) cfg.startMaster() } else { glog.Infof("Starting node with cfg %v", cfg) cfg.startNode() } } else { cfg.startAllInOne() } }, } flag := cmd.Flags() flag.StringVar(&cfg.ListenAddr, "listenAddr", "127.0.0.1:8080", "The OpenShift server listen address.") dockerHelper.InstallFlags(flag) return cmd }
func setupAppConfig(f *clientcmd.Factory, out io.Writer, c *cobra.Command, args []string, config *newcmd.AppConfig) error { namespace, _, err := f.DefaultNamespace() if err != nil { return err } dockerClient, _, err := dockerutil.NewHelper().GetClient() if err == nil { if err = dockerClient.Ping(); err == nil { config.SetDockerClient(dockerClient) } } if err != nil { glog.V(2).Infof("No local Docker daemon detected: %v", err) } osclient, _, err := f.Clients() if err != nil { return err } config.SetOpenShiftClient(osclient, namespace) config.Out = out config.ErrOut = c.Out() unknown := config.AddArguments(args) if len(unknown) != 0 { return cmdutil.UsageError(c, "Did not recognize the following arguments: %v", unknown) } if config.AllowMissingImages && config.AsSearch { return cmdutil.UsageError(c, "--allow-missing-images and --search are mutually exclusive.") } return nil }
// run is responsible for preparing environment for actual build. // It accepts factoryFunc and an ordered array of SCMAuths. func run(builderFactory factoryFunc, scmAuths []scmauth.SCMAuth) { client, endpoint, err := dockerutil.NewHelper().GetClient() if err != nil { glog.Fatalf("Error obtaining docker client: %v", err) } buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) build := api.Build{} if err := latest.Codec.DecodeInto([]byte(buildStr), &build); err != nil { glog.Fatalf("Unable to parse build: %v", err) } if build.Spec.Source.SourceSecret != nil { if err := setupSourceSecret(build.Spec.Source.SourceSecret.Name, scmAuths); err != nil { glog.Fatalf("Cannot setup secret file for accessing private repository: %v", err) } } b := builderFactory(client, endpoint, &build) if err = b.Build(); err != nil { glog.Fatalf("Build error: %v", err) } if build.Spec.Output.To == nil || len(build.Spec.Output.To.Name) == 0 { glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.") } }
func newBuilderConfigFromEnvironment() (*builderConfig, error) { cfg := &builderConfig{} var err error // build (BUILD) buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) cfg.build = &api.Build{} if err = latest.Codec.DecodeInto([]byte(buildStr), cfg.build); err != nil { return nil, fmt.Errorf("unable to parse build: %v", err) } // sourceSecretsDir (SOURCE_SECRET_PATH) cfg.sourceSecretDir = os.Getenv("SOURCE_SECRET_PATH") // dockerClient and dockerEndpoint (DOCKER_HOST) // usually not set, defaults to docker socket cfg.dockerClient, cfg.dockerEndpoint, err = dockerutil.NewHelper().GetClient() if err != nil { return nil, fmt.Errorf("error obtaining docker client: %v", err) } // buildsClient (KUBERNETES_SERVICE_HOST, KUBERNETES_SERVICE_PORT) clientConfig, err := kclient.InClusterConfig() if err != nil { return nil, fmt.Errorf("failed to get client config: %v", err) } osClient, err := client.New(clientConfig) if err != nil { return nil, fmt.Errorf("error obtaining OpenShift client: %v", err) } cfg.buildsClient = osClient.Builds(cfg.build.Namespace) return cfg, nil }
// run is responsible for preparing environment for actual build. // It accepts factoryFunc and an ordered array of SCMAuths. func run(builderFactory factoryFunc) { client, endpoint, err := dockerutil.NewHelper().GetClient() if err != nil { glog.Fatalf("Error obtaining docker client: %v", err) } buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) build := api.Build{} if err := latest.Codec.DecodeInto([]byte(buildStr), &build); err != nil { glog.Fatalf("Unable to parse build: %v", err) } if build.Spec.Source.SourceSecret != nil { if build.Spec.Source.Git != nil { // TODO: this should be refactored to let each source type manage which secrets // it accepts sourceURL, err := git.ParseRepository(build.Spec.Source.Git.URI) if err != nil { glog.Fatalf("Cannot parse build URL: %s", build.Spec.Source.Git.URI) } scmAuths := auths(sourceURL) if err := setupSourceSecret(build.Spec.Source.SourceSecret.Name, scmAuths); err != nil { glog.Fatalf("Cannot setup secret file for accessing private repository: %v", err) } } } b := builderFactory(client, endpoint, &build) if err = b.Build(); err != nil { glog.Fatalf("Build error: %v", err) } if build.Spec.Output.To == nil || len(build.Spec.Output.To.Name) == 0 { glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.") } }
func setupAppConfig(f *clientcmd.Factory, out io.Writer, c *cobra.Command, args []string, config *newcmd.AppConfig) error { namespace, _, err := f.DefaultNamespace() if err != nil { return err } dockerClient, _, err := dockerutil.NewHelper().GetClient() if err == nil { if err = dockerClient.Ping(); err == nil { config.SetDockerClient(dockerClient) } else { glog.V(4).Infof("Docker client did not respond to a ping: %v", err) } } if err != nil { glog.V(2).Infof("No local Docker daemon detected: %v", err) } osclient, kclient, err := f.Clients() if err != nil { return err } config.KubeClient = kclient config.SetOpenShiftClient(osclient, namespace) // Only output="" should print descriptions of intermediate steps. Everything // else should print only some specific output (json, yaml, go-template, ...) output := cmdutil.GetFlagString(c, "output") if len(output) == 0 { config.Out = out } else { config.Out = ioutil.Discard } config.ErrOut = c.Out() if config.AllowSecretUse { cfg, err := f.OpenShiftClientConfig.ClientConfig() if err != nil { return err } config.SecretAccessor = newConfigSecretRetriever(cfg) } unknown := config.AddArguments(args) if len(unknown) != 0 { return cmdutil.UsageError(c, "Did not recognize the following arguments: %v", unknown) } if config.AllowMissingImages && config.AsSearch { return cmdutil.UsageError(c, "--allow-missing-images and --search are mutually exclusive.") } if len(config.SourceImage) != 0 && len(config.SourceImagePath) == 0 { return cmdutil.UsageError(c, "--source-image-path must be specified when --source-image is specified.") } if len(config.SourceImage) == 0 && len(config.SourceImagePath) != 0 { return cmdutil.UsageError(c, "--source-image must be specified when --source-image-path is specified.") } return nil }
// run is responsible for preparing environment for actual build. // It accepts factoryFunc and an ordered array of SCMAuths. func run(builderFactory factoryFunc, scmAuths []scmauth.SCMAuth) { client, endpoint, err := dockerutil.NewHelper().GetClient() if err != nil { glog.Fatalf("Error obtaining docker client: %v", err) } buildStr := os.Getenv("BUILD") build := api.Build{} if err := latest.Codec.DecodeInto([]byte(buildStr), &build); err != nil { glog.Fatalf("Unable to parse build: %v", err) } var ( authcfg docker.AuthConfiguration authPresent bool ) output := build.Spec.Output.To != nil && len(build.Spec.Output.To.Name) != 0 if output { authcfg, authPresent = dockercfg.NewHelper().GetDockerAuth( build.Spec.Output.To.Name, dockercfg.PullAuthType, ) } if build.Spec.Source.SourceSecret != nil { if err := setupSourceSecret(build.Spec.Source.SourceSecret.Name, scmAuths); err != nil { glog.Fatalf("Cannot setup secret file for accessing private repository: %v", err) } } b := builderFactory(client, endpoint, authcfg, authPresent, &build) if err = b.Build(); err != nil { glog.Fatalf("Build error: %v", err) } if !output { glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.") } }
func StartNode(nodeConfig configapi.NodeConfig) error { config, err := kubernetes.BuildKubernetesNodeConfig(nodeConfig) if err != nil { return err } glog.Infof("Starting node %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) // preconditions config.EnsureVolumeDir() config.EnsureDocker(docker.NewHelper()) // async starts config.RunKubelet() config.RunSDN() config.RunProxy() // HACK: RunProxy resets bridge-nf-call-iptables from what openshift-sdn requires if config.SDNPlugin != nil { sdnPluginName := nodeConfig.NetworkConfig.NetworkPluginName if sdnPluginName == osdn.SingleTenantPluginName() || sdnPluginName == osdn.MultiTenantPluginName() { if err := sysctl.SetSysctl("net/bridge/bridge-nf-call-iptables", 0); err != nil { glog.Warningf("Could not set net.bridge.bridge-nf-call-iptables sysctl: %s", err) } } } return nil }
// getDockerClient obtains a new Docker client from the environment or // from a Docker machine, starting it if necessary and permitted func getDockerClient(out io.Writer, dockerMachine string, canStartDockerMachine bool) (*docker.Client, *dockerclient.Client, error) { if len(dockerMachine) > 0 { glog.V(2).Infof("Getting client for Docker machine %q", dockerMachine) dockerClient, engineAPIClient, err := getDockerMachineClient(dockerMachine, out, canStartDockerMachine) if err != nil { return nil, nil, errors.ErrNoDockerMachineClient(dockerMachine, err) } return dockerClient, engineAPIClient, nil } dockerTLSVerify := os.Getenv("DOCKER_TLS_VERIFY") dockerCertPath := os.Getenv("DOCKER_CERT_PATH") if len(dockerTLSVerify) > 0 && len(dockerCertPath) == 0 { dockerCertPath = cliconfig.ConfigDir() os.Setenv("DOCKER_CERT_PATH", dockerCertPath) } if glog.V(4) { dockerHost := os.Getenv("DOCKER_HOST") if len(dockerHost) == 0 && len(dockerTLSVerify) == 0 && len(dockerCertPath) == 0 { glog.Infof("No Docker environment variables found. Will attempt default socket.") } if len(dockerHost) > 0 { glog.Infof("Will try Docker connection with host (DOCKER_HOST) %q", dockerHost) } else { glog.Infof("No Docker host (DOCKER_HOST) configured. Will attempt default socket.") } if len(dockerTLSVerify) > 0 { glog.Infof("DOCKER_TLS_VERIFY=%s", dockerTLSVerify) } if len(dockerCertPath) > 0 { glog.Infof("DOCKER_CERT_PATH=%s", dockerCertPath) } } dockerClient, _, err := dockerutil.NewHelper().GetClient() if err != nil { return nil, nil, errors.ErrNoDockerClient(err) } // FIXME: Workaround for docker engine API client on OS X - sets the default to // the wrong DOCKER_HOST string if runtime.GOOS == "darwin" { dockerHost := os.Getenv("DOCKER_HOST") if len(dockerHost) == 0 { os.Setenv("DOCKER_HOST", "unix:///var/run/docker.sock") } } engineAPIClient, err := dockerclient.NewEnvClient() if err != nil { return nil, nil, errors.ErrNoDockerClient(err) } if err = dockerClient.Ping(); err != nil { return nil, nil, errors.ErrCannotPingDocker(err) } glog.V(4).Infof("Docker ping succeeded") return dockerClient, engineAPIClient, nil }
func (c *ClientStopConfig) getDockerClient(out io.Writer) (*docker.Client, error) { // Get Docker client if len(c.DockerMachine) > 0 { return getDockerMachineClient(c.DockerMachine, out) } client, _, err := dockerutil.NewHelper().GetClient() if err != nil { return nil, errors.ErrNoDockerClient(err) } return client, nil }
// getDockerClient returns a client capable of communicating with the local // docker daemon. If an error occurs (such as no local daemon being available), // it will return nil. func getDockerClient() (*docker.Client, error) { dockerClient, _, err := dockerutil.NewHelper().GetClient() if err == nil { if err = dockerClient.Ping(); err != nil { glog.V(4).Infof("Docker client did not respond to a ping: %v", err) return nil, err } return dockerClient, nil } glog.V(2).Infof("No local Docker daemon detected: %v", err) return nil, err }
func StartNode(nodeConfig configapi.NodeConfig, components *utilflags.ComponentFlag) error { config, err := kubernetes.BuildKubernetesNodeConfig(nodeConfig, components.Enabled(ComponentProxy), components.Enabled(ComponentDNS)) if err != nil { return err } // In case of openshift network plugin, nodeConfig.networkPluginName is optional and is auto detected/finalized // once we build kubernetes node config. So perform plugin name related check here. if osdn.IsOpenShiftNetworkPlugin(config.KubeletServer.NetworkPluginName) { // TODO: SDN plugin depends on the Kubelet registering as a Node and doesn't retry cleanly, // and Kubelet also can't start the PodSync loop until the SDN plugin has loaded. if components.Enabled(ComponentKubelet) != components.Enabled(ComponentPlugins) { return fmt.Errorf("the SDN plugin must be run in the same process as the kubelet") } } if components.Enabled(ComponentKubelet) { glog.Infof("Starting node %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) } else { glog.Infof("Starting node networking %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) } _, kubeClientConfig, err := configapi.GetKubeClient(nodeConfig.MasterKubeConfig) if err != nil { return err } glog.Infof("Connecting to API server %s", kubeClientConfig.Host) // preconditions if components.Enabled(ComponentKubelet) { config.EnsureKubeletAccess() config.EnsureVolumeDir() config.EnsureDocker(docker.NewHelper()) config.EnsureLocalQuota(nodeConfig) // must be performed after EnsureVolumeDir } if components.Enabled(ComponentKubelet) { config.RunKubelet() } if components.Enabled(ComponentPlugins) { config.RunPlugin() } if components.Enabled(ComponentProxy) { config.RunProxy() } if components.Enabled(ComponentDNS) { config.RunDNS() } config.RunServiceStores(components.Enabled(ComponentProxy), components.Enabled(ComponentDNS)) return nil }
func NewCommandTour(name string) *cobra.Command { dockerHelper := docker.NewHelper() cmd := &cobra.Command{ Use: name, Short: "An interactive OpenShift tour", Long: longDescription, Run: func(c *cobra.Command, args []string) { tour(dockerHelper) }, } dockerHelper.InstallFlags(cmd.Flags()) return cmd }
func StartNode(nodeConfig configapi.NodeConfig) error { config, err := kubernetes.BuildKubernetesNodeConfig(nodeConfig) if err != nil { return err } RunSDNController(config, nodeConfig) config.EnsureVolumeDir() config.EnsureDocker(docker.NewHelper()) config.RunProxy() config.RunKubelet() return nil }
func newBuilderConfigFromEnvironment(out io.Writer) (*builderConfig, error) { cfg := &builderConfig{} var err error cfg.out = out // build (BUILD) buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) cfg.build = &api.Build{} if err := runtime.DecodeInto(kapi.Codecs.UniversalDecoder(), []byte(buildStr), cfg.build); err != nil { return nil, fmt.Errorf("unable to parse build: %v", err) } if errs := validation.ValidateBuild(cfg.build); len(errs) > 0 { return nil, errors.NewInvalid(unversioned.GroupKind{Kind: "Build"}, cfg.build.Name, errs) } glog.V(4).Infof("Build: %#v", cfg.build) masterVersion := os.Getenv(api.OriginVersion) thisVersion := version.Get().String() if len(masterVersion) != 0 && masterVersion != thisVersion { fmt.Fprintf(cfg.out, "warning: OpenShift server version %q differs from this image %q\n", masterVersion, thisVersion) } else { glog.V(4).Infof("Master version %q, Builder version %q", masterVersion, thisVersion) } // sourceSecretsDir (SOURCE_SECRET_PATH) cfg.sourceSecretDir = os.Getenv("SOURCE_SECRET_PATH") // dockerClient and dockerEndpoint (DOCKER_HOST) // usually not set, defaults to docker socket cfg.dockerClient, cfg.dockerEndpoint, err = dockerutil.NewHelper().GetClient() if err != nil { return nil, fmt.Errorf("no Docker configuration defined: %v", err) } // buildsClient (KUBERNETES_SERVICE_HOST, KUBERNETES_SERVICE_PORT) clientConfig, err := restclient.InClusterConfig() if err != nil { return nil, fmt.Errorf("cannot connect to the server: %v", err) } osClient, err := client.New(clientConfig) if err != nil { return nil, fmt.Errorf("failed to get client: %v", err) } cfg.buildsClient = osClient.Builds(cfg.build.Namespace) return cfg, nil }
// run is responsible for preparing environment for actual build. // It accepts factoryFunc and an ordered array of SCMAuths. func run(b builder) { dockerClient, endpoint, err := dockerutil.NewHelper().GetClient() if err != nil { glog.Fatalf("Error obtaining docker client: %v", err) } buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) build := api.Build{} if err := latest.Codec.DecodeInto([]byte(buildStr), &build); err != nil { glog.Fatalf("Unable to parse build: %v", err) } if build.Spec.Source.SourceSecret != nil { if build.Spec.Source.Git != nil { // TODO: this should be refactored to let each source type manage which secrets // it accepts sourceURL, err := git.ParseRepository(build.Spec.Source.Git.URI) if err != nil { glog.Fatalf("Cannot parse build URL: %s", build.Spec.Source.Git.URI) } scmAuths := auths(sourceURL) sourceURL, err = setupSourceSecret(build.Spec.Source.SourceSecret.Name, scmAuths) if err != nil { glog.Fatalf("Cannot setup secret file for accessing private repository: %v", err) } if sourceURL != nil { build.Annotations[bld.OriginalSourceURLAnnotationKey] = build.Spec.Source.Git.URI build.Spec.Source.Git.URI = sourceURL.String() } } } config, err := kclient.InClusterConfig() if err != nil { glog.Fatalf("Failed to get client config: %v", err) } osClient, err := client.New(config) if err != nil { glog.Fatalf("Error obtaining OpenShift client: %v", err) } buildsClient := osClient.Builds(build.Namespace) if err = b.Build(dockerClient, endpoint, buildsClient, &build); err != nil { glog.Fatalf("Build error: %v", err) } if build.Spec.Output.To == nil || len(build.Spec.Output.To.Name) == 0 { glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.") } }
func StartNode(nodeConfig configapi.NodeConfig) error { config, err := kubernetes.BuildKubernetesNodeConfig(nodeConfig) if err != nil { return err } glog.Infof("Starting node %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) RunSDNController(config, nodeConfig) config.EnsureVolumeDir() config.EnsureDocker(docker.NewHelper()) config.RunProxy() config.RunKubelet() return nil }
func StartNode(nodeConfig configapi.NodeConfig, components *utilflags.ComponentFlag) error { config, err := kubernetes.BuildKubernetesNodeConfig(nodeConfig) if err != nil { return err } if components.Enabled(ComponentKubelet) { glog.Infof("Starting node %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) } else { glog.Infof("Starting node networking %s (%s)", config.KubeletServer.HostnameOverride, version.Get().String()) } _, kubeClientConfig, err := configapi.GetKubeClient(nodeConfig.MasterKubeConfig) if err != nil { return err } glog.Infof("Connecting to API server %s", kubeClientConfig.Host) // preconditions if components.Enabled(ComponentKubelet) { config.EnsureKubeletAccess() config.EnsureVolumeDir() config.EnsureDocker(docker.NewHelper()) config.EnsureLocalQuota(nodeConfig) // must be performed after EnsureVolumeDir } // TODO: SDN plugin depends on the Kubelet registering as a Node and doesn't retry cleanly, // and Kubelet also can't start the PodSync loop until the SDN plugin has loaded. if components.Enabled(ComponentKubelet) { config.RunKubelet() } // SDN plugins get the opportunity to filter service rules, so they start first if components.Enabled(ComponentPlugins) { config.RunPlugin() } if components.Enabled(ComponentProxy) { config.RunProxy() } // if we are running plugins in this process, reset the bridge ip rule if components.Enabled(ComponentPlugins) { config.ResetSysctlFromProxy() } return nil }
func newBuilderConfigFromEnvironment() (*builderConfig, error) { cfg := &builderConfig{} var err error // build (BUILD) buildStr := os.Getenv("BUILD") glog.V(4).Infof("$BUILD env var is %s \n", buildStr) cfg.build = &api.Build{} if err = runtime.DecodeInto(kapi.Codecs.UniversalDecoder(), []byte(buildStr), cfg.build); err != nil { return nil, fmt.Errorf("unable to parse build: %v", err) } masterVersion := os.Getenv(api.OriginVersion) thisVersion := version.Get().String() if len(masterVersion) != 0 && masterVersion != thisVersion { glog.Warningf("Master version %q does not match Builder image version %q", masterVersion, thisVersion) } else { glog.V(2).Infof("Master version %q, Builder version %q", masterVersion, thisVersion) } // sourceSecretsDir (SOURCE_SECRET_PATH) cfg.sourceSecretDir = os.Getenv("SOURCE_SECRET_PATH") // dockerClient and dockerEndpoint (DOCKER_HOST) // usually not set, defaults to docker socket cfg.dockerClient, cfg.dockerEndpoint, err = dockerutil.NewHelper().GetClient() if err != nil { return nil, fmt.Errorf("error obtaining docker client: %v", err) } // buildsClient (KUBERNETES_SERVICE_HOST, KUBERNETES_SERVICE_PORT) clientConfig, err := restclient.InClusterConfig() if err != nil { return nil, fmt.Errorf("failed to get client config: %v", err) } osClient, err := client.New(clientConfig) if err != nil { return nil, fmt.Errorf("error obtaining OpenShift client: %v", err) } cfg.buildsClient = osClient.Builds(cfg.build.Namespace) return cfg, nil }
func NewCommandStartAllInOne(name string) *cobra.Command { dockerHelper := docker.NewHelper() cfg := &config{Docker: *dockerHelper} cmd := &cobra.Command{ Use: name, Short: "Launch in all-in-one mode", Run: func(c *cobra.Command, args []string) { cfg.startAllInOne() }, } flag := cmd.Flags() flag.StringVar(&cfg.ListenAddr, "listenAddr", "127.0.0.1:8080", "The OpenShift server listen address.") dockerHelper.InstallFlags(flag) return cmd }
// GetDockerClient will obtain a new Docker client from the environment or // from a Docker machine, starting it if necessary func (c *ClientStartConfig) GetDockerClient(out io.Writer) error { var err error if len(c.DockerMachine) > 0 { glog.V(2).Infof("Getting client for Docker machine %q", c.DockerMachine) c.dockerClient, err = getDockerMachineClient(c.DockerMachine, out) if err != nil { return errors.ErrNoDockerMachineClient(c.DockerMachine, err) } return nil } if glog.V(4) { dockerHost := os.Getenv("DOCKER_HOST") dockerTLSVerify := os.Getenv("DOCKER_TLS_VERIFY") dockerCertPath := os.Getenv("DOCKER_CERT_PATH") if len(dockerHost) == 0 && len(dockerTLSVerify) == 0 && len(dockerCertPath) == 0 { glog.Infof("No Docker environment variables found. Will attempt default socket.") } if len(dockerHost) > 0 { glog.Infof("Will try Docker connection with host (DOCKER_HOST) %q", dockerHost) } else { glog.Infof("No Docker host (DOCKER_HOST) configured. Will attempt default socket.") } if len(dockerTLSVerify) > 0 { glog.Infof("DOCKER_TLS_VERIFY=%s", dockerTLSVerify) } if len(dockerCertPath) > 0 { glog.Infof("DOCKER_CERT_PATH=%s", dockerCertPath) } } c.dockerClient, _, err = dockerutil.NewHelper().GetClient() if err != nil { return errors.ErrNoDockerClient(err) } if err = c.dockerClient.Ping(); err != nil { return errors.ErrCannotPingDocker(err) } glog.V(4).Infof("Docker ping succeeded") return nil }