use new method to detect cgroup driver

cmd/kubeadm/app/phases/kubelet/flags_test.go

@@ -66,23 +66,23 @@ func (f fakeExecer) LookPath(file string) (string, error) { return "", errors.Ne
 var (
 	systemdCgroupExecer = fakeExecer{
 		ioMap: map[string]fakeCmd{
-			"docker info": {
+			"docker info -f {{.CgroupDriver}}": {
-				b: []byte(`Cgroup Driver: systemd`),
+				b: []byte(`systemd`),
 			},
 		},
 	}
 
 	cgroupfsCgroupExecer = fakeExecer{
 		ioMap: map[string]fakeCmd{
-			"docker info": {
+			"docker info -f {{.CgroupDriver}}": {
-				b: []byte(`Cgroup Driver: cgroupfs`),
+				b: []byte(`cgroupfs`),
 			},
 		},
 	}
 
 	errCgroupExecer = fakeExecer{
 		ioMap: map[string]fakeCmd{
-			"docker info": {
+			"docker info -f {{.CgroupDriver}}": {
 				err: errors.New("no such binary: docker"),
 			},
 		},

cmd/kubeadm/app/util/cgroupdriver.go

@@ -36,13 +36,13 @@ const (
 // Discussion:
 //     https://github.com/kubernetes/kubeadm/issues/844
 
-// GetCgroupDriverDocker runs 'docker info' to obtain the docker cgroup driver
+// GetCgroupDriverDocker runs 'docker info -f "{{.CgroupDriver}}"' to obtain the docker cgroup driver
 func GetCgroupDriverDocker(execer utilsexec.Interface) (string, error) {
-	info, err := callDockerInfo(execer)
+	driver, err := callDockerInfo(execer)
 	if err != nil {
 		return "", err
 	}
-	return getCgroupDriverFromDockerInfo(info)
+	return strings.TrimSuffix(driver, "\n"), nil
 }
 
 func validateCgroupDriver(driver string) error {
@@ -52,32 +52,10 @@ func validateCgroupDriver(driver string) error {
 	return nil
 }
 
-// TODO: Docker 1.13 has a new way to obatain the cgroup driver:
-//     docker info -f "{{.CgroupDriver}}
-// If the minimum supported Docker version in K8s becomes 1.13, move to
-// this syntax.
 func callDockerInfo(execer utilsexec.Interface) (string, error) {
-	out, err := execer.Command("docker", "info").Output()
+	out, err := execer.Command("docker", "info", "-f", "{{.CgroupDriver}}").Output()
 	if err != nil {
 		return "", errors.Wrap(err, "cannot execute 'docker info'")
 	}
 	return string(out), nil
 }
-
-func getCgroupDriverFromDockerInfo(info string) (string, error) {
-	lineSeparator := ": "
-	prefix := "Cgroup Driver"
-	for _, line := range strings.Split(info, "\n") {
-		if !strings.Contains(line, prefix+lineSeparator) {
-			continue
-		}
-		lineSplit := strings.Split(line, lineSeparator)
-		// At this point len(lineSplit) is always >= 2
-		driver := lineSplit[1]
-		if err := validateCgroupDriver(driver); err != nil {
-			return "", err
-		}
-		return driver, nil
-	}
-	return "", errors.New("cgroup driver is not defined in 'docker info'")
-}

cmd/kubeadm/app/util/cgroupdriver_test.go

@@ -23,45 +23,36 @@ import (
 func TestGetCgroupDriverDocker(t *testing.T) {
 	testCases := []struct {
 		name          string
-		info          string
+		driver        string
 		expectedError bool
 	}{
 		{
 			name:          "valid: value is 'cgroupfs'",
-			info:          `Cgroup Driver: cgroupfs`,
+			driver:        `cgroupfs`,
 			expectedError: false,
 		},
 		{
 			name:          "valid: value is 'systemd'",
-			info:          `Cgroup Driver: systemd`,
+			driver:        `systemd`,
 			expectedError: false,
 		},
-		{
-			name:          "invalid: missing 'Cgroup Driver' key and value",
-			info:          "",
-			expectedError: true,
-		},
-		{
-			name:          "invalid: only a 'Cgroup Driver' key is present",
-			info:          `Cgroup Driver`,
-			expectedError: true,
-		},
 		{
 			name:          "invalid: empty 'Cgroup Driver' value",
-			info:          `Cgroup Driver: `,
+			driver:        ``,
 			expectedError: true,
 		},
 		{
 			name:          "invalid: unknown 'Cgroup Driver' value",
-			info:          `Cgroup Driver: invalid-value`,
+			driver:        `invalid-value`,
 			expectedError: true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			if _, err := getCgroupDriverFromDockerInfo(tc.info); (err != nil) != tc.expectedError {
+			result := tc.driver != CgroupDriverCgroupfs && tc.driver != CgroupDriverSystemd
-				t.Fatalf("expected error: %v, saw: %v, error: %v", tc.expectedError, (err != nil), err)
+			if result != tc.expectedError {
+				t.Fatalf("expected error: %v, saw: %v", tc.expectedError, result)
 			}
 		})
 	}