Merge pull request #19875 from mfojtik/up-10-remove-remote-docker

up: remove support for remote docker host

Author: openshift-merge-robot

pkg/oc/clusteradd/components/registry/registry_install.go

@@ -2,7 +2,6 @@ package registry
 
 import (
 	"fmt"
-	"os"
 	"path"
 	"path/filepath"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/openshift/origin/pkg/oc/clusteradd/componentinstall"
 	"github.com/openshift/origin/pkg/oc/clusterup/coreinstall/kubeapiserver"
 	"github.com/openshift/origin/pkg/oc/clusterup/docker/dockerhelper"
-	"github.com/openshift/origin/pkg/oc/clusterup/docker/host"
 	"github.com/openshift/origin/pkg/oc/clusterup/docker/run"
 	"github.com/openshift/origin/pkg/oc/errors"
 )
@@ -58,7 +56,7 @@ func (r *RegistryComponentOptions) Install(dockerClient dockerhelper.Interface)
 	if err != nil {
 		return err
 	}
-	_, err = kubeAdminClient.Core().Services(DefaultNamespace).Get(SvcDockerRegistry, metav1.GetOptions{})
+	_, err = kubeAdminClient.CoreV1().Services(DefaultNamespace).Get(SvcDockerRegistry, metav1.GetOptions{})
 	if err == nil {
 		// If there's no error, the registry already exists
 		return nil
@@ -72,23 +70,8 @@ func (r *RegistryComponentOptions) Install(dockerClient dockerhelper.Interface)
 		return err
 	}
 
-	// If docker is on remote host, the base dir is different.
-	baseDir := r.InstallContext.BaseDir()
-	if len(os.Getenv("DOCKER_HOST")) > 0 {
-		baseDir = path.Join(host.RemoteHostOriginDir, r.InstallContext.BaseDir())
-	}
-
-	registryStorageDir := path.Join(baseDir, "openshift.local.pv")
-
-	// If docker is on remote host, ensure the permissions for registry
-	if len(os.Getenv("DOCKER_HOST")) > 0 {
-		if err := r.ensureRemoteRegistryStoragePermissions(registryStorageDir, dockerClient); err != nil {
-			return errors.NewError("error ensuring remote host registry directory permissions").WithCause(err)
-		}
-	}
-	registryStorageDir = path.Join(registryStorageDir, "registry")
-
-	masterConfigDir := path.Join(baseDir, kubeapiserver.KubeAPIServerDirName)
+	registryStorageDir := path.Join(r.InstallContext.BaseDir(), "openshift.local.pv", "registry")
+	masterConfigDir := path.Join(r.InstallContext.BaseDir(), kubeapiserver.KubeAPIServerDirName)
 	flags := []string{
 		"adm",
 		"registry",

pkg/oc/clusteradd/components/router/router_install.go

@@ -11,8 +11,6 @@ import (
 	goruntime "runtime"
 
 	"github.com/golang/glog"
-	"github.com/openshift/origin/pkg/oc/clusterup/docker/host"
-
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -111,19 +109,6 @@ func (c *RouterComponentOptions) Install(dockerClient dockerhelper.Interface) er
 		return errors.NewError("cannot create aggregate router cert").WithCause(err)
 	}
 
-	dockerHelper := dockerhelper.NewHelper(dockerClient)
-
-	// This snowflake makes sure that when the Docker is on remote host, we copy the generated cert into
-	// the Docker host master config dir.
-	if len(os.Getenv("DOCKER_HOST")) > 0 {
-		hostHelper := host.NewHostHelper(dockerHelper, c.InstallContext.ClientImage())
-		remoteMasterConfigDir := path.Join(host.RemoteHostOriginDir, c.InstallContext.BaseDir(), kubeapiserver.KubeAPIServerDirName)
-		if err := hostHelper.CopyToHost(masterConfigDir, remoteMasterConfigDir); err != nil {
-			return err
-		}
-		masterConfigDir = remoteMasterConfigDir
-	}
-
 	routerCertPath := masterConfigDir + "/router.pem"
 
 	flags := []string{

pkg/oc/clusterup/coreinstall/components/persistent-volumes/setup_persistent_volumes.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/golang/glog"
 	"github.com/openshift/origin/pkg/oc/admin/policy"
-	"github.com/openshift/origin/pkg/oc/clusterup/docker/host"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -125,9 +124,6 @@ func (c *SetupPersistentVolumesOptions) Install(dockerClient dockerhelper.Interf
 		return fmt.Errorf("error retrieving job to setup persistent volumes (%s/%s): %v", pvTargetNamespace, pvSetupJobName, err)
 	}
 	targetDir := path.Join(c.InstallContext.BaseDir(), "openshift.local.pv")
-	if len(os.Getenv("DOCKER_HOST")) > 0 {
-		targetDir = path.Join(host.RemoteHostOriginDir, targetDir)
-	}
 
 	if _, err := os.Stat(path.Join(targetDir, pvIgnoreMarkerFile)); !os.IsNotExist(err) {
 		glog.Infof("Found %q marker file, skipping persistent volume setup", path.Join(targetDir, pvIgnoreMarkerFile))

pkg/oc/clusterup/docker/host/host.go

@@ -2,10 +2,7 @@ package host
 
 import (
 	"fmt"
-	"path"
 
-	"github.com/docker/docker/api/types"
-	"github.com/golang/glog"
 	"github.com/openshift/origin/pkg/oc/clusterup/docker/dockerhelper"
 	"github.com/openshift/origin/pkg/oc/clusterup/docker/errors"
 	"github.com/openshift/origin/pkg/oc/clusterup/docker/run"
@@ -54,51 +51,6 @@ func (h *HostHelper) CanUseNsenterMounter() (bool, error) {
 	return err == nil && rc == 0, err
 }
 
-func (h *HostHelper) CopyToHost(src, dst string) error {
-	containerID, err := h.runner().
-		Image(h.image).
-		DiscardContainer().
-		Privileged().
-		HostPid().
-		Bind("/:/rootfs:rw").
-		Entrypoint("/bin/bash").
-		Command("-c", fmt.Sprintf("mkdir -p /rootfs/%s && sleep infinity", dst)).Start()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		h.client.ContainerStop(containerID, 1)
-		h.client.ContainerRemove(containerID, types.ContainerRemoveOptions{})
-	}()
-	err = dockerhelper.UploadFileToContainer(h.client, containerID, src, path.Join("/rootfs", dst))
-	if err != nil {
-		return err
-	}
-	glog.V(2).Infof("Succesfully copied %s to %s:%s", src, containerID, dst)
-	return nil
-}
-
-func (h *HostHelper) CopyFromHost(src, dst string) error {
-	containerID, err := h.runner().
-		Image(h.image).
-		DiscardContainer().
-		Privileged().
-		HostPid().
-		Bind("/:/rootfs:rw").
-		Entrypoint("/bin/bash").
-		Command("-c", "sleep infinity").Start()
-	if err != nil {
-		return err
-	}
-	defer h.client.ContainerStop(containerID, 1)
-	err = dockerhelper.DownloadDirFromContainer(h.client, containerID, src, path.Join("/rootfs", dst))
-	if err != nil {
-		return err
-	}
-	glog.V(2).Infof("Succesfully copied %s to %s:%s", src, containerID, dst)
-	return nil
-}
-
 // EnsureVolumeUseShareMount ensures that the host Docker VM has a shared directory that can be used
 // for OpenShift volumes. This is needed for Docker for Mac.
 func (h *HostHelper) EnsureVolumeUseShareMount(volumesDir string) error {

pkg/oc/clusterup/run_self_hosted.go

@@ -256,17 +256,11 @@ func (c *ClusterUpConfig) LocalDirFor(componentName string) string {
 }
 
 // RemoteDirFor returns a directory path on remote host
+// DEPRECATED:
 func (c *ClusterUpConfig) RemoteDirFor(componentName string) string {
 	return filepath.Join(host.RemoteHostOriginDir, c.BaseDir, componentName)
 }
 
-func (c *ClusterUpConfig) copyToRemote(source, component string) (string, error) {
-	if err := c.hostHelper.CopyToHost(source, c.RemoteDirFor(component)); err != nil {
-		return "", err
-	}
-	return c.RemoteDirFor(component), nil
-}
-
 func (c *ClusterUpConfig) BuildConfig() (*configDirs, error) {
 	configs := &configDirs{
 		masterConfigDir:              filepath.Join(c.BaseDir, kubeapiserver.KubeAPIServerDirName),
@@ -279,59 +273,34 @@ func (c *ClusterUpConfig) BuildConfig() (*configDirs, error) {
 
 	originalMasterConfigDir := configs.masterConfigDir
 	originalNodeConfigDir := configs.nodeConfigDir
-	var err error
 
 	if _, err := os.Stat(configs.masterConfigDir); os.IsNotExist(err) {
 		_, err = c.makeMasterConfig()
 		if err != nil {
 			return nil, err
 		}
 	}
-	if c.isRemoteDocker {
-		configs.masterConfigDir, err = c.copyToRemote(configs.masterConfigDir, kubeapiserver.KubeAPIServerDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if _, err := os.Stat(configs.openshiftAPIServerConfigDir); os.IsNotExist(err) {
 		_, err = c.makeOpenShiftAPIServerConfig(originalMasterConfigDir)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if c.isRemoteDocker {
-		configs.openshiftAPIServerConfigDir, err = c.copyToRemote(configs.openshiftAPIServerConfigDir, kubeapiserver.OpenShiftAPIServerDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if _, err := os.Stat(configs.openshiftControllerConfigDir); os.IsNotExist(err) {
 		_, err = c.makeOpenShiftControllerConfig(originalMasterConfigDir)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if c.isRemoteDocker {
-		configs.openshiftControllerConfigDir, err = c.copyToRemote(configs.openshiftControllerConfigDir, kubeapiserver.OpenShiftControllerManagerDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if _, err := os.Stat(configs.nodeConfigDir); os.IsNotExist(err) {
 		_, err = c.makeNodeConfig(configs.masterConfigDir)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if c.isRemoteDocker {
-		configs.nodeConfigDir, err = c.copyToRemote(configs.nodeConfigDir, kubelet.NodeConfigDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if _, err := os.Stat(configs.kubeDNSConfigDir); os.IsNotExist(err) {
 		_, err = c.makeKubeDNSConfig(originalNodeConfigDir)
@@ -340,12 +309,6 @@ func (c *ClusterUpConfig) BuildConfig() (*configDirs, error) {
 		}
 
 	}
-	if c.isRemoteDocker {
-		configs.kubeDNSConfigDir, err = c.copyToRemote(configs.kubeDNSConfigDir, kubelet.KubeDNSDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if _, err := os.Stat(configs.podManifestDir); os.IsNotExist(err) {
 		if err := os.MkdirAll(configs.podManifestDir, 0755); err != nil {
@@ -379,12 +342,6 @@ func (c *ClusterUpConfig) BuildConfig() (*configDirs, error) {
 		}
 	}
 
-	if c.isRemoteDocker {
-		configs.podManifestDir, err = c.copyToRemote(configs.podManifestDir, kubelet.PodManifestDirName)
-		if err != nil {
-			return nil, err
-		}
-	}
 	glog.V(2).Infof("configLocations = %#v", *configs)
 
 	return configs, nil

pkg/oc/clusterup/up.go

@@ -327,35 +327,22 @@ func (c *ClusterUpConfig) Complete(cmd *cobra.Command) error {
 	if c.UseNsenterMount {
 		// This is default path when you run cluster up locally, with local docker daemon
 		c.HostVolumesDir = path.Join(c.BaseDir, "openshift.local.volumes")
-		// This is a snowflake when Docker runs on remote host
-		if c.isRemoteDocker {
-			c.HostVolumesDir = c.RemoteDirFor("openshift.local.volumes")
-		} else {
-			if err := os.MkdirAll(c.HostVolumesDir, 0755); err != nil {
-				return err
-			}
+		if err := os.MkdirAll(c.HostVolumesDir, 0755); err != nil {
+			return err
 		}
 	} else {
 		// Snowflake for OSX Docker for Mac
 		c.HostVolumesDir = c.RemoteDirFor("openshift.local.volumes")
 	}
 
 	c.HostPersistentVolumesDir = path.Join(c.BaseDir, "openshift.local.pv")
-	if c.isRemoteDocker {
-		c.HostPersistentVolumesDir = c.RemoteDirFor("openshift.local.pv")
-	} else {
-		if err := os.MkdirAll(c.HostPersistentVolumesDir, 0755); err != nil {
-			return err
-		}
+	if err := os.MkdirAll(c.HostPersistentVolumesDir, 0755); err != nil {
+		return err
 	}
 
 	c.HostDataDir = path.Join(c.BaseDir, "etcd")
-	if c.isRemoteDocker {
-		c.HostDataDir = c.RemoteDirFor("etcd")
-	} else {
-		if err := os.MkdirAll(c.HostDataDir, 0755); err != nil {
-			return err
-		}
+	if err := os.MkdirAll(c.HostDataDir, 0755); err != nil {
+		return err
 	}
 
 	// Ensure that host directories exist.