Use official Docker client

libmachine/mcndockerclient/docker_client.go

 package mcndockerclient
 
 import (
+	"context"
 	"fmt"
+	"net/http"
 
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
 	"github.com/docker/machine/libmachine/cert"
-	"github.com/samalba/dockerclient"
+	v1 "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 // DockerClient creates a docker client for a given host.
-func DockerClient(dockerHost DockerHost) (*dockerclient.DockerClient, error) {
+func DockerClient(dockerHost DockerHost) (*client.Client, error) {
 	url, err := dockerHost.URL()
 	if err != nil {
 		return nil, err
@@ -19,27 +25,35 @@ func DockerClient(dockerHost DockerHost) (*dockerclient.DockerClient, error) {
 		return nil, fmt.Errorf("Unable to read TLS config: %s", err)
 	}
 
-	return dockerclient.NewDockerClient(url, tlsConfig)
+	httpClient := &http.Client{
+		Transport:     &http.Transport{TLSClientConfig: tlsConfig},
+		CheckRedirect: client.CheckRedirect,
+	}
+
+	return client.NewClientWithOpts(
+		client.WithHTTPClient(httpClient),
+		client.WithHost(url),
+		client.WithAPIVersionNegotiation(),
+	)
 }
 
 // CreateContainer creates a docker container.
-func CreateContainer(dockerHost DockerHost, config *dockerclient.ContainerConfig, name string) error {
+func CreateContainer(dockerHost DockerHost, config *container.Config, hostConfig *container.HostConfig, name string) error {
 	docker, err := DockerClient(dockerHost)
 	if err != nil {
 		return err
 	}
 
-	if err = docker.PullImage(config.Image, nil); err != nil {
+	if _, err = docker.ImagePull(context.Background(), config.Image, types.ImagePullOptions{}); err != nil {
 		return fmt.Errorf("Unable to pull image: %s", err)
 	}
 
-	var authConfig *dockerclient.AuthConfig
-	containerID, err := docker.CreateContainer(config, name, authConfig)
+	containerCreateResp, err := docker.ContainerCreate(context.Background(), config, hostConfig, &network.NetworkingConfig{}, &v1.Platform{}, name)
 	if err != nil {
 		return fmt.Errorf("Error while creating container: %s", err)
 	}
 
-	if err = docker.StartContainer(containerID, &config.HostConfig); err != nil {
+	if err = docker.ContainerStart(context.Background(), containerCreateResp.ID, types.ContainerStartOptions{}); err != nil {
 		return fmt.Errorf("Error while starting container: %s", err)
 	}
 

libmachine/mcndockerclient/docker_versioner.go

 package mcndockerclient
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+)
 
 var CurrentDockerVersioner DockerVersioner = &defaultDockerVersioner{}
 
@@ -20,7 +23,7 @@ func (dv *defaultDockerVersioner) DockerVersion(host DockerHost) (string, error)
 		return "", fmt.Errorf("Unable to query docker version: %s", err)
 	}
 
-	version, err := client.Version()
+	version, err := client.ServerVersion(context.Background())
 	if err != nil {
 		return "", fmt.Errorf("Unable to query docker version: %s", err)
 	}

libmachine/provision/configure_swarm.go

@@ -6,12 +6,13 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/go-connections/nat"
 	"github.com/docker/machine/libmachine/auth"
 	"github.com/docker/machine/libmachine/engine"
 	"github.com/docker/machine/libmachine/log"
 	"github.com/docker/machine/libmachine/mcndockerclient"
 	"github.com/docker/machine/libmachine/swarm"
-	"github.com/samalba/dockerclient"
 )
 
 func configureSwarm(p Provisioner, swarmOptions swarm.Options, authOptions auth.Options) error {
@@ -79,42 +80,41 @@ func configureSwarm(p Provisioner, swarmOptions swarm.Options, authOptions auth.
 		cmdMaster = append(cmdMaster, swarmOptions.Discovery)
 
 		hostBind := fmt.Sprintf("%s:%s", dockerDir, dockerDir)
-		masterHostConfig := dockerclient.HostConfig{
-			RestartPolicy: dockerclient.RestartPolicy{
+		masterHostConfig := &container.HostConfig{
+			RestartPolicy: container.RestartPolicy{
 				Name:              "always",
 				MaximumRetryCount: 0,
 			},
 			Binds: []string{hostBind},
-			PortBindings: map[string][]dockerclient.PortBinding{
-				fmt.Sprintf("%s/tcp", port): {
+			PortBindings: nat.PortMap{
+				nat.Port(fmt.Sprintf("%s/tcp", port)): {
 					{
-						HostIp:   "0.0.0.0",
+						HostIP:   "0.0.0.0",
 						HostPort: port,
 					},
 				},
 			},
 		}
 
-		swarmMasterConfig := &dockerclient.ContainerConfig{
+		swarmMasterConfig := &container.Config{
 			Image: swarmOptions.Image,
 			Env:   swarmOptions.Env,
-			ExposedPorts: map[string]struct{}{
+			ExposedPorts: nat.PortSet{
 				"2375/tcp":                            {},
-				fmt.Sprintf("%s/tcp", port): {},
+				nat.Port(fmt.Sprintf("%s/tcp", port)): {},
 			},
 			Cmd: cmdMaster,
-			HostConfig: masterHostConfig,
 		}
 
-		err = mcndockerclient.CreateContainer(dockerHost, swarmMasterConfig, "swarm-agent-master")
+		err = mcndockerclient.CreateContainer(dockerHost, swarmMasterConfig, masterHostConfig, "swarm-agent-master")
 		if err != nil {
 			return err
 		}
 	}
 
 	if swarmOptions.Agent {
-		workerHostConfig := dockerclient.HostConfig{
-			RestartPolicy: dockerclient.RestartPolicy{
+		workerHostConfig := &container.HostConfig{
+			RestartPolicy: container.RestartPolicy{
 				Name:              "always",
 				MaximumRetryCount: 0,
 			},
@@ -130,17 +130,16 @@ func configureSwarm(p Provisioner, swarmOptions swarm.Options, authOptions auth.
 		}
 		cmdWorker = append(cmdWorker, swarmOptions.Discovery)
 
-		swarmWorkerConfig := &dockerclient.ContainerConfig{
+		swarmWorkerConfig := &container.Config{
 			Image: swarmOptions.Image,
 			Env:   swarmOptions.Env,
 			Cmd:   cmdWorker,
-			HostConfig: workerHostConfig,
 		}
 		if swarmOptions.IsExperimental {
 			swarmWorkerConfig.Cmd = append([]string{"--experimental"}, swarmWorkerConfig.Cmd...)
 		}
 
-		err = mcndockerclient.CreateContainer(dockerHost, swarmWorkerConfig, "swarm-agent")
+		err = mcndockerclient.CreateContainer(dockerHost, swarmWorkerConfig, workerHostConfig, "swarm-agent")
 		if err != nil {
 			return err
 		}