vendor update for CSI 0.3.0

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/BUILD

@@ -8,11 +8,18 @@ load(
 
 go_library(
     name = "go_default_library",
-    srcs = ["images.go"],
+    srcs = [
+        "images.go",
+        "interface.go",
+    ],
     importpath = "k8s.io/kubernetes/cmd/kubeadm/app/images",
     deps = [
+        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
+        "//cmd/kubeadm/app/apis/kubeadm/v1alpha2:go_default_library",
         "//cmd/kubeadm/app/constants:go_default_library",
+        "//cmd/kubeadm/app/features:go_default_library",
         "//cmd/kubeadm/app/util:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
     ],
 )
 
@@ -20,7 +27,10 @@ go_test(
     name = "go_default_test",
     srcs = ["images_test.go"],
     embed = [":go_default_library"],
-    deps = ["//cmd/kubeadm/app/constants:go_default_library"],
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm:go_default_library",
+        "//cmd/kubeadm/app/constants:go_default_library",
+    ],
 )
 
 filegroup(
@@ -35,3 +45,13 @@ filegroup(
     srcs = [":package-srcs"],
     tags = ["automanaged"],
 )
+
+go_test(
+    name = "go_default_xtest",
+    srcs = ["interface_test.go"],
+    deps = [
+        ":go_default_library",
+        "//cmd/kubeadm/app/apis/kubeadm/v1alpha2:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/images.go

@@ -20,10 +20,17 @@ import (
 	"fmt"
 	"runtime"
 
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
+	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 )
 
+// GetGenericImage generates and returns a platform agnostic image (backed by manifest list)
+func GetGenericImage(prefix, image, tag string) string {
+	return fmt.Sprintf("%s/%s:%s", prefix, image, tag)
+}
+
 // GetCoreImage generates and returns the image for the core Kubernetes components or returns overrideImage if specified
 func GetCoreImage(image, repoPrefix, k8sVersion, overrideImage string) string {
 	if overrideImage != "" {
@@ -42,3 +49,28 @@ func GetCoreImage(image, repoPrefix, k8sVersion, overrideImage string) string {
 		constants.KubeScheduler:         fmt.Sprintf("%s/%s-%s:%s", repoPrefix, "kube-scheduler", runtime.GOARCH, kubernetesImageTag),
 	}[image]
 }
+
+// GetAllImages returns a list of container images kubeadm expects to use on a control plane node
+func GetAllImages(cfg *kubeadmapi.MasterConfiguration) []string {
+	repoPrefix := cfg.GetControlPlaneImageRepository()
+	imgs := []string{}
+	imgs = append(imgs, GetCoreImage(constants.KubeAPIServer, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
+	imgs = append(imgs, GetCoreImage(constants.KubeControllerManager, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
+	imgs = append(imgs, GetCoreImage(constants.KubeScheduler, repoPrefix, cfg.KubernetesVersion, cfg.UnifiedControlPlaneImage))
+	imgs = append(imgs, fmt.Sprintf("%v/%v-%v:%v", repoPrefix, constants.KubeProxy, runtime.GOARCH, kubeadmutil.KubernetesVersionToImageTag(cfg.KubernetesVersion)))
+
+	// pause, etcd and kube-dns are not available on the ci image repository so use the default image repository.
+	imgs = append(imgs, GetGenericImage(cfg.ImageRepository, "pause", "3.1"))
+
+	// if etcd is not external then add the image as it will be required
+	if cfg.Etcd.Local != nil {
+		imgs = append(imgs, GetCoreImage(constants.Etcd, cfg.ImageRepository, cfg.KubernetesVersion, cfg.Etcd.Local.Image))
+	}
+
+	dnsImage := fmt.Sprintf("%v/k8s-dns-kube-dns-%v:%v", cfg.ImageRepository, runtime.GOARCH, constants.KubeDNSVersion)
+	if features.Enabled(cfg.FeatureGates, features.CoreDNS) {
+		dnsImage = fmt.Sprintf("%v/coredns:%v", cfg.ImageRepository, constants.CoreDNSVersion)
+	}
+	imgs = append(imgs, dnsImage)
+	return imgs
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/images_test.go

@@ -19,8 +19,10 @@ package images
 import (
 	"fmt"
 	"runtime"
+	"strings"
 	"testing"
 
+	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
 
@@ -73,3 +75,46 @@ func TestGetCoreImage(t *testing.T) {
 		}
 	}
 }
+
+func TestGetAllImages(t *testing.T) {
+	testcases := []struct {
+		name   string
+		cfg    *kubeadmapi.MasterConfiguration
+		expect string
+	}{
+		{
+			name: "defined CIImageRepository",
+			cfg: &kubeadmapi.MasterConfiguration{
+				CIImageRepository: "test.repo",
+			},
+			expect: "test.repo",
+		},
+		{
+			name: "undefined CIImagerRepository should contain the default image prefix",
+			cfg: &kubeadmapi.MasterConfiguration{
+				ImageRepository: "real.repo",
+			},
+			expect: "real.repo",
+		},
+		{
+			name: "test that etcd is returned when it is not external",
+			cfg: &kubeadmapi.MasterConfiguration{
+				Etcd: kubeadmapi.Etcd{
+					Local: &kubeadmapi.LocalEtcd{},
+				},
+			},
+			expect: constants.Etcd,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			imgs := GetAllImages(tc.cfg)
+			for _, img := range imgs {
+				if strings.Contains(img, tc.expect) {
+					return
+				}
+			}
+			t.Fatalf("did not find %q in %q", tc.expect, imgs)
+		})
+	}
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/interface.go

@@ -0,0 +1,89 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package images
+
+import (
+	"fmt"
+
+	kubeadmapiv1alpha2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha2"
+	utilsexec "k8s.io/utils/exec"
+)
+
+// Puller is an interface for pulling images
+type Puller interface {
+	Pull(string) error
+}
+
+// Existence is an interface to determine if an image exists on the system
+// A nil error means the image was found
+type Existence interface {
+	Exists(string) error
+}
+
+// Images defines the set of behaviors needed for images relating to the CRI
+type Images interface {
+	Puller
+	Existence
+}
+
+// CRInterfacer is a struct that interfaces with the container runtime
+type CRInterfacer struct {
+	criSocket  string
+	exec       utilsexec.Interface
+	crictlPath string
+	dockerPath string
+}
+
+// NewCRInterfacer sets up and returns a CRInterfacer
+func NewCRInterfacer(execer utilsexec.Interface, criSocket string) (*CRInterfacer, error) {
+	var crictlPath, dockerPath string
+	var err error
+	if criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
+		if crictlPath, err = execer.LookPath("crictl"); err != nil {
+			return nil, fmt.Errorf("crictl is required for non docker container runtimes: %v", err)
+		}
+	} else {
+		// use the dockershim
+		if dockerPath, err = execer.LookPath("docker"); err != nil {
+			return nil, fmt.Errorf("`docker` is required when docker is the container runtime and the kubelet is not running: %v", err)
+		}
+	}
+
+	return &CRInterfacer{
+		exec:       execer,
+		criSocket:  criSocket,
+		crictlPath: crictlPath,
+		dockerPath: dockerPath,
+	}, nil
+}
+
+// Pull pulls the actual image using either crictl or docker
+func (cri *CRInterfacer) Pull(image string) error {
+	if cri.criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
+		return cri.exec.Command(cri.crictlPath, "-r", cri.criSocket, "pull", image).Run()
+	}
+	return cri.exec.Command(cri.dockerPath, "pull", image).Run()
+}
+
+// Exists checks to see if the image exists on the system already
+// Returns an error if the image is not found.
+func (cri *CRInterfacer) Exists(image string) error {
+	if cri.criSocket != kubeadmapiv1alpha2.DefaultCRISocket {
+		return cri.exec.Command(cri.crictlPath, "-r", cri.criSocket, "inspecti", image).Run()
+	}
+	return cri.exec.Command(cri.dockerPath, "inspect", image).Run()
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/images/interface_test.go

@@ -0,0 +1,266 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package images_test
+
+import (
+	"context"
+	"errors"
+	"io"
+	"testing"
+
+	kubeadmapiv1alpha2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha2"
+	"k8s.io/kubernetes/cmd/kubeadm/app/images"
+	"k8s.io/utils/exec"
+)
+
+type fakeCmd struct {
+	err error
+}
+
+func (f *fakeCmd) Run() error {
+	return f.err
+}
+func (f *fakeCmd) CombinedOutput() ([]byte, error) { return nil, nil }
+func (f *fakeCmd) Output() ([]byte, error)         { return nil, nil }
+func (f *fakeCmd) SetDir(dir string)               {}
+func (f *fakeCmd) SetStdin(in io.Reader)           {}
+func (f *fakeCmd) SetStdout(out io.Writer)         {}
+func (f *fakeCmd) SetStderr(out io.Writer)         {}
+func (f *fakeCmd) Stop()                           {}
+
+type fakeExecer struct {
+	cmd        exec.Cmd
+	findCrictl bool
+	findDocker bool
+}
+
+func (f *fakeExecer) Command(cmd string, args ...string) exec.Cmd { return f.cmd }
+func (f *fakeExecer) CommandContext(ctx context.Context, cmd string, args ...string) exec.Cmd {
+	return f.cmd
+}
+func (f *fakeExecer) LookPath(file string) (string, error) {
+	if file == "crictl" {
+		if f.findCrictl {
+			return "/path", nil
+		}
+		return "", errors.New("no crictl for you")
+	}
+	if file == "docker" {
+		if f.findDocker {
+			return "/path", nil
+		}
+		return "", errors.New("no docker for you")
+	}
+	return "", errors.New("unknown binary")
+}
+
+func TestNewCRInterfacer(t *testing.T) {
+	testcases := []struct {
+		name        string
+		criSocket   string
+		findCrictl  bool
+		findDocker  bool
+		expectError bool
+	}{
+		{
+			name:        "need crictl but can only find docker should return an error",
+			criSocket:   "/not/docker",
+			findCrictl:  false,
+			findDocker:  true,
+			expectError: true,
+		},
+		{
+			name:        "need crictl and cannot find either should return an error",
+			criSocket:   "/not/docker",
+			findCrictl:  false,
+			findDocker:  false,
+			expectError: true,
+		},
+		{
+			name:        "need crictl and cannot find docker should return no error",
+			criSocket:   "/not/docker",
+			findCrictl:  true,
+			findDocker:  false,
+			expectError: false,
+		},
+		{
+			name:        "need crictl and can find both should return no error",
+			criSocket:   "/not/docker",
+			findCrictl:  true,
+			findDocker:  true,
+			expectError: false,
+		},
+		{
+			name:        "need docker and cannot find crictl should return no error",
+			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
+			findCrictl:  false,
+			findDocker:  true,
+			expectError: false,
+		},
+		{
+			name:        "need docker and cannot find docker should return an error",
+			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
+			findCrictl:  false,
+			findDocker:  false,
+			expectError: true,
+		},
+		{
+			name:        "need docker and can find both should return no error",
+			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
+			findCrictl:  true,
+			findDocker:  true,
+			expectError: false,
+		},
+		{
+			name:        "need docker and can only find crictl should return an error",
+			criSocket:   kubeadmapiv1alpha2.DefaultCRISocket,
+			findCrictl:  true,
+			findDocker:  false,
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			fe := &fakeExecer{
+				findCrictl: tc.findCrictl,
+				findDocker: tc.findDocker,
+			}
+			_, err := images.NewCRInterfacer(fe, tc.criSocket)
+			if tc.expectError && err == nil {
+				t.Fatal("expected an error but did not get one")
+			}
+			if !tc.expectError && err != nil {
+				t.Fatalf("did not expedt an error but got an error: %v", err)
+			}
+		})
+	}
+}
+
+func TestImagePuller(t *testing.T) {
+	testcases := []struct {
+		name          string
+		criSocket     string
+		pullFails     bool
+		errorExpected bool
+	}{
+		{
+			name:          "using docker and pull fails",
+			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
+			pullFails:     true,
+			errorExpected: true,
+		},
+		{
+			name:          "using docker and pull succeeds",
+			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
+			pullFails:     false,
+			errorExpected: false,
+		},
+		{
+			name:          "using crictl pull fails",
+			criSocket:     "/not/default",
+			pullFails:     true,
+			errorExpected: true,
+		},
+		{
+			name:          "using crictl and pull succeeds",
+			criSocket:     "/not/default",
+			pullFails:     false,
+			errorExpected: false,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			var err error
+			if tc.pullFails {
+				err = errors.New("error")
+			}
+
+			fe := &fakeExecer{
+				cmd:        &fakeCmd{err},
+				findCrictl: true,
+				findDocker: true,
+			}
+			ip, _ := images.NewCRInterfacer(fe, tc.criSocket)
+
+			err = ip.Pull("imageName")
+			if tc.errorExpected && err == nil {
+				t.Fatal("expected an error and did not get one")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Fatalf("expected no error but got one: %v", err)
+			}
+		})
+	}
+}
+
+func TestImageExists(t *testing.T) {
+	testcases := []struct {
+		name          string
+		criSocket     string
+		existFails    bool
+		errorExpected bool
+	}{
+		{
+			name:          "using docker and exist fails",
+			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
+			existFails:    true,
+			errorExpected: true,
+		},
+		{
+			name:          "using docker and exist succeeds",
+			criSocket:     kubeadmapiv1alpha2.DefaultCRISocket,
+			existFails:    false,
+			errorExpected: false,
+		},
+		{
+			name:          "using crictl exist fails",
+			criSocket:     "/not/default",
+			existFails:    true,
+			errorExpected: true,
+		},
+		{
+			name:          "using crictl and exist succeeds",
+			criSocket:     "/not/default",
+			existFails:    false,
+			errorExpected: false,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			var err error
+			if tc.existFails {
+				err = errors.New("error")
+			}
+
+			fe := &fakeExecer{
+				cmd:        &fakeCmd{err},
+				findCrictl: true,
+				findDocker: true,
+			}
+			ip, _ := images.NewCRInterfacer(fe, tc.criSocket)
+
+			err = ip.Exists("imageName")
+			if tc.errorExpected && err == nil {
+				t.Fatal("expected an error and did not get one")
+			}
+			if !tc.errorExpected && err != nil {
+				t.Fatalf("expected no error but got one: %v", err)
+			}
+		})
+	}
+}