Bumping k8s dependencies to 1.13

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/runtime/BUILD

@@ -0,0 +1,38 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["runtime.go"],
+    importpath = "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["runtime_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//cmd/kubeadm/app/apis/kubeadm/v1alpha3:go_default_library",
+        "//vendor/k8s.io/utils/exec:go_default_library",
+        "//vendor/k8s.io/utils/exec/testing:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/runtime/runtime.go

@@ -0,0 +1,181 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"path/filepath"
+	goruntime "runtime"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/util/errors"
+	kubeadmapiv1alpha3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3"
+	utilsexec "k8s.io/utils/exec"
+)
+
+// ContainerRuntime is an interface for working with container runtimes
+type ContainerRuntime interface {
+	IsDocker() bool
+	IsRunning() error
+	ListKubeContainers() ([]string, error)
+	RemoveContainers(containers []string) error
+	PullImage(image string) error
+	ImageExists(image string) (bool, error)
+}
+
+// CRIRuntime is a struct that interfaces with the CRI
+type CRIRuntime struct {
+	exec      utilsexec.Interface
+	criSocket string
+}
+
+// DockerRuntime is a struct that interfaces with the Docker daemon
+type DockerRuntime struct {
+	exec utilsexec.Interface
+}
+
+// NewContainerRuntime sets up and returns a ContainerRuntime struct
+func NewContainerRuntime(execer utilsexec.Interface, criSocket string) (ContainerRuntime, error) {
+	var toolName string
+	var runtime ContainerRuntime
+
+	if criSocket != kubeadmapiv1alpha3.DefaultCRISocket {
+		toolName = "crictl"
+		// !!! temporary work around crictl warning:
+		// Using "/var/run/crio/crio.sock" as endpoint is deprecated,
+		// please consider using full url format "unix:///var/run/crio/crio.sock"
+		if filepath.IsAbs(criSocket) && goruntime.GOOS != "windows" {
+			criSocket = "unix://" + criSocket
+		}
+		runtime = &CRIRuntime{execer, criSocket}
+	} else {
+		toolName = "docker"
+		runtime = &DockerRuntime{execer}
+	}
+
+	if _, err := execer.LookPath(toolName); err != nil {
+		return nil, fmt.Errorf("%s is required for container runtime: %v", toolName, err)
+	}
+
+	return runtime, nil
+}
+
+// IsDocker returns true if the runtime is docker
+func (runtime *CRIRuntime) IsDocker() bool {
+	return false
+}
+
+// IsDocker returns true if the runtime is docker
+func (runtime *DockerRuntime) IsDocker() bool {
+	return true
+}
+
+// IsRunning checks if runtime is running
+func (runtime *CRIRuntime) IsRunning() error {
+	if out, err := runtime.exec.Command("crictl", "-r", runtime.criSocket, "info").CombinedOutput(); err != nil {
+		return fmt.Errorf("container runtime is not running: output: %s, error: %v", string(out), err)
+	}
+	return nil
+}
+
+// IsRunning checks if runtime is running
+func (runtime *DockerRuntime) IsRunning() error {
+	if out, err := runtime.exec.Command("docker", "info").CombinedOutput(); err != nil {
+		return fmt.Errorf("container runtime is not running: output: %s, error: %v", string(out), err)
+	}
+	return nil
+}
+
+// ListKubeContainers lists running k8s CRI pods
+func (runtime *CRIRuntime) ListKubeContainers() ([]string, error) {
+	out, err := runtime.exec.Command("crictl", "-r", runtime.criSocket, "pods", "-q").CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("output: %s, error: %v", string(out), err)
+	}
+	pods := []string{}
+	for _, pod := range strings.Fields(string(out)) {
+		pods = append(pods, pod)
+	}
+	return pods, nil
+}
+
+// ListKubeContainers lists running k8s containers
+func (runtime *DockerRuntime) ListKubeContainers() ([]string, error) {
+	output, err := runtime.exec.Command("docker", "ps", "-a", "--filter", "name=k8s_", "-q").CombinedOutput()
+	return strings.Fields(string(output)), err
+}
+
+// RemoveContainers removes running k8s pods
+func (runtime *CRIRuntime) RemoveContainers(containers []string) error {
+	errs := []error{}
+	for _, container := range containers {
+		out, err := runtime.exec.Command("crictl", "-r", runtime.criSocket, "stopp", container).CombinedOutput()
+		if err != nil {
+			// don't stop on errors, try to remove as many containers as possible
+			errs = append(errs, fmt.Errorf("failed to stop running pod %s: output: %s, error: %v", container, string(out), err))
+		} else {
+			out, err = runtime.exec.Command("crictl", "-r", runtime.criSocket, "rmp", container).CombinedOutput()
+			if err != nil {
+				errs = append(errs, fmt.Errorf("failed to remove running container %s: output: %s, error: %v", container, string(out), err))
+			}
+		}
+	}
+	return errors.NewAggregate(errs)
+}
+
+// RemoveContainers removes running containers
+func (runtime *DockerRuntime) RemoveContainers(containers []string) error {
+	errs := []error{}
+	for _, container := range containers {
+		out, err := runtime.exec.Command("docker", "rm", "--force", "--volumes", container).CombinedOutput()
+		if err != nil {
+			// don't stop on errors, try to remove as many containers as possible
+			errs = append(errs, fmt.Errorf("failed to remove running container %s: output: %s, error: %v", container, string(out), err))
+		}
+	}
+	return errors.NewAggregate(errs)
+}
+
+// PullImage pulls the image
+func (runtime *CRIRuntime) PullImage(image string) error {
+	out, err := runtime.exec.Command("crictl", "-r", runtime.criSocket, "pull", image).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("output: %s, error: %v", string(out), err)
+	}
+	return nil
+}
+
+// PullImage pulls the image
+func (runtime *DockerRuntime) PullImage(image string) error {
+	out, err := runtime.exec.Command("docker", "pull", image).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("output: %s, error: %v", string(out), err)
+	}
+	return nil
+}
+
+// ImageExists checks to see if the image exists on the system
+func (runtime *CRIRuntime) ImageExists(image string) (bool, error) {
+	err := runtime.exec.Command("crictl", "-r", runtime.criSocket, "inspecti", image).Run()
+	return err == nil, nil
+}
+
+// ImageExists checks to see if the image exists on the system
+func (runtime *DockerRuntime) ImageExists(image string) (bool, error) {
+	err := runtime.exec.Command("docker", "inspect", image).Run()
+	return err == nil, nil
+}

vendor/k8s.io/kubernetes/cmd/kubeadm/app/util/runtime/runtime_test.go

@@ -0,0 +1,306 @@
+/*
+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 util
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	kubeadmapiv1alpha3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1alpha3"
+	"k8s.io/utils/exec"
+	fakeexec "k8s.io/utils/exec/testing"
+)
+
+func TestNewContainerRuntime(t *testing.T) {
+	execLookPathOK := fakeexec.FakeExec{
+		LookPathFunc: func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+	execLookPathErr := fakeexec.FakeExec{
+		LookPathFunc: func(cmd string) (string, error) { return "", fmt.Errorf("%s not found", cmd) },
+	}
+	cases := []struct {
+		name      string
+		execer    fakeexec.FakeExec
+		criSocket string
+		isDocker  bool
+		isError   bool
+	}{
+		{"valid: default cri socket", execLookPathOK, kubeadmapiv1alpha3.DefaultCRISocket, true, false},
+		{"valid: cri-o socket url", execLookPathOK, "unix:///var/run/crio/crio.sock", false, false},
+		{"valid: cri-o socket path", execLookPathOK, "/var/run/crio/crio.sock", false, false},
+		{"invalid: no crictl", execLookPathErr, "unix:///var/run/crio/crio.sock", false, true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&tc.execer, tc.criSocket)
+			if err != nil {
+				if !tc.isError {
+					t.Fatalf("unexpected NewContainerRuntime error. criSocket: %s, error: %v", tc.criSocket, err)
+				}
+				return // expected error occurs, impossible to test runtime further
+			}
+			if tc.isError && err == nil {
+				t.Fatalf("unexpected NewContainerRuntime success. criSocket: %s", tc.criSocket)
+			}
+			isDocker := runtime.IsDocker()
+			if tc.isDocker != isDocker {
+				t.Fatalf("unexpected isDocker() result %v for the criSocket %s", isDocker, tc.criSocket)
+			}
+		})
+	}
+}
+
+func genFakeActions(fcmd *fakeexec.FakeCmd, num int) []fakeexec.FakeCommandAction {
+	var actions []fakeexec.FakeCommandAction
+	for i := 0; i < num; i++ {
+		actions = append(actions, func(cmd string, args ...string) exec.Cmd {
+			return fakeexec.InitFakeCmd(fcmd, cmd, args...)
+		})
+	}
+	return actions
+}
+
+func TestIsRunning(t *testing.T) {
+	fcmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			func() ([]byte, error) { return nil, nil },
+			func() ([]byte, error) { return []byte("error"), &fakeexec.FakeExitError{Status: 1} },
+			func() ([]byte, error) { return nil, nil },
+			func() ([]byte, error) { return []byte("error"), &fakeexec.FakeExitError{Status: 1} },
+		},
+	}
+
+	criExecer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.CombinedOutputScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+
+	dockerExecer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.CombinedOutputScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/docker", nil },
+	}
+
+	cases := []struct {
+		name      string
+		criSocket string
+		execer    fakeexec.FakeExec
+		isError   bool
+	}{
+		{"valid: CRI-O is running", "unix:///var/run/crio/crio.sock", criExecer, false},
+		{"invalid: CRI-O is not running", "unix:///var/run/crio/crio.sock", criExecer, true},
+		{"valid: docker is running", kubeadmapiv1alpha3.DefaultCRISocket, dockerExecer, false},
+		{"invalid: docker is not running", kubeadmapiv1alpha3.DefaultCRISocket, dockerExecer, true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&tc.execer, tc.criSocket)
+			if err != nil {
+				t.Fatalf("unexpected NewContainerRuntime error: %v", err)
+			}
+			isRunning := runtime.IsRunning()
+			if tc.isError && isRunning == nil {
+				t.Error("unexpected IsRunning() success")
+			}
+			if !tc.isError && isRunning != nil {
+				t.Error("unexpected IsRunning() error")
+			}
+		})
+	}
+}
+
+func TestListKubeContainers(t *testing.T) {
+	fcmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			func() ([]byte, error) { return []byte("k8s_p1\nk8s_p2"), nil },
+			func() ([]byte, error) { return nil, &fakeexec.FakeExitError{Status: 1} },
+			func() ([]byte, error) { return []byte("k8s_p1\nk8s_p2"), nil },
+		},
+	}
+	execer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.CombinedOutputScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+
+	cases := []struct {
+		name      string
+		criSocket string
+		isError   bool
+	}{
+		{"valid: list containers using CRI socket url", "unix:///var/run/crio/crio.sock", false},
+		{"invalid: list containers using CRI socket url", "unix:///var/run/crio/crio.sock", true},
+		{"valid: list containers using docker", kubeadmapiv1alpha3.DefaultCRISocket, false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&execer, tc.criSocket)
+			if err != nil {
+				t.Fatalf("unexpected NewContainerRuntime error: %v", err)
+			}
+
+			containers, err := runtime.ListKubeContainers()
+			if tc.isError {
+				if err == nil {
+					t.Errorf("unexpected ListKubeContainers success")
+				}
+				return
+			} else if err != nil {
+				t.Errorf("unexpected ListKubeContainers error: %v", err)
+			}
+
+			if !reflect.DeepEqual(containers, []string{"k8s_p1", "k8s_p2"}) {
+				t.Errorf("unexpected ListKubeContainers output: %v", containers)
+			}
+		})
+	}
+}
+
+func TestRemoveContainers(t *testing.T) {
+	fakeOK := func() ([]byte, error) { return nil, nil }
+	fakeErr := func() ([]byte, error) { return []byte("error"), &fakeexec.FakeExitError{Status: 1} }
+	fcmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			fakeOK, fakeOK, fakeOK, fakeOK, fakeOK, fakeOK, // Test case 1
+			fakeOK, fakeOK, fakeOK, fakeErr, fakeOK, fakeOK,
+			fakeErr, fakeOK, fakeOK, fakeErr, fakeOK,
+			fakeOK, fakeOK, fakeOK,
+			fakeOK, fakeErr, fakeOK,
+		},
+	}
+	execer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.CombinedOutputScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+
+	cases := []struct {
+		name       string
+		criSocket  string
+		containers []string
+		isError    bool
+	}{
+		{"valid: remove containers using CRI", "unix:///var/run/crio/crio.sock", []string{"k8s_p1", "k8s_p2", "k8s_p3"}, false}, // Test case 1
+		{"invalid: CRI rmp failure", "unix:///var/run/crio/crio.sock", []string{"k8s_p1", "k8s_p2", "k8s_p3"}, true},
+		{"invalid: CRI stopp failure", "unix:///var/run/crio/crio.sock", []string{"k8s_p1", "k8s_p2", "k8s_p3"}, true},
+		{"valid: remove containers using docker", kubeadmapiv1alpha3.DefaultCRISocket, []string{"k8s_c1", "k8s_c2", "k8s_c3"}, false},
+		{"invalid: remove containers using docker", kubeadmapiv1alpha3.DefaultCRISocket, []string{"k8s_c1", "k8s_c2", "k8s_c3"}, true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&execer, tc.criSocket)
+			if err != nil {
+				t.Fatalf("unexpected NewContainerRuntime error: %v, criSocket: %s", err, tc.criSocket)
+			}
+
+			err = runtime.RemoveContainers(tc.containers)
+			if !tc.isError && err != nil {
+				t.Errorf("unexpected RemoveContainers errors: %v, criSocket: %s, containers: %v", err, tc.criSocket, tc.containers)
+			}
+			if tc.isError && err == nil {
+				t.Errorf("unexpected RemoveContnainers success, criSocket: %s, containers: %v", tc.criSocket, tc.containers)
+			}
+		})
+	}
+}
+
+func TestPullImage(t *testing.T) {
+	fcmd := fakeexec.FakeCmd{
+		CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
+			func() ([]byte, error) { return nil, nil },
+			func() ([]byte, error) { return []byte("error"), &fakeexec.FakeExitError{Status: 1} },
+			func() ([]byte, error) { return nil, nil },
+			func() ([]byte, error) { return []byte("error"), &fakeexec.FakeExitError{Status: 1} },
+		},
+	}
+	execer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.CombinedOutputScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+
+	cases := []struct {
+		name      string
+		criSocket string
+		image     string
+		isError   bool
+	}{
+		{"valid: pull image using CRI", "unix:///var/run/crio/crio.sock", "image1", false},
+		{"invalid: CRI pull error", "unix:///var/run/crio/crio.sock", "image2", true},
+		{"valid: pull image using docker", kubeadmapiv1alpha3.DefaultCRISocket, "image1", false},
+		{"invalide: docer pull error", kubeadmapiv1alpha3.DefaultCRISocket, "image2", true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&execer, tc.criSocket)
+			if err != nil {
+				t.Fatalf("unexpected NewContainerRuntime error: %v, criSocket: %s", err, tc.criSocket)
+			}
+
+			err = runtime.PullImage(tc.image)
+			if !tc.isError && err != nil {
+				t.Errorf("unexpected PullImage error: %v, criSocket: %s, image: %s", err, tc.criSocket, tc.image)
+			}
+			if tc.isError && err == nil {
+				t.Errorf("unexpected PullImage success, criSocket: %s, image: %s", tc.criSocket, tc.image)
+			}
+		})
+	}
+}
+
+func TestImageExists(t *testing.T) {
+	fcmd := fakeexec.FakeCmd{
+		RunScript: []fakeexec.FakeRunAction{
+			func() ([]byte, []byte, error) { return nil, nil, nil },
+			func() ([]byte, []byte, error) { return nil, nil, &fakeexec.FakeExitError{Status: 1} },
+			func() ([]byte, []byte, error) { return nil, nil, nil },
+			func() ([]byte, []byte, error) { return nil, nil, &fakeexec.FakeExitError{Status: 1} },
+		},
+	}
+	execer := fakeexec.FakeExec{
+		CommandScript: genFakeActions(&fcmd, len(fcmd.RunScript)),
+		LookPathFunc:  func(cmd string) (string, error) { return "/usr/bin/crictl", nil },
+	}
+
+	cases := []struct {
+		name      string
+		criSocket string
+		image     string
+		result    bool
+	}{
+		{"valid: test if image exists using CRI", "unix:///var/run/crio/crio.sock", "image1", false},
+		{"invalid: CRI inspecti failure", "unix:///var/run/crio/crio.sock", "image2", true},
+		{"valid: test if image exists using docker", kubeadmapiv1alpha3.DefaultCRISocket, "image1", false},
+		{"invalid: docker inspect failure", kubeadmapiv1alpha3.DefaultCRISocket, "image2", true},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			runtime, err := NewContainerRuntime(&execer, tc.criSocket)
+			if err != nil {
+				t.Fatalf("unexpected NewContainerRuntime error: %v, criSocket: %s", err, tc.criSocket)
+			}
+
+			result, err := runtime.ImageExists(tc.image)
+			if !tc.result != result {
+				t.Errorf("unexpected ImageExists result: %t, criSocket: %s, image: %s, expected result: %t", err, tc.criSocket, tc.image, tc.result)
+			}
+		})
+	}
+}