Merge pull request #46238 from yguo0905/package-validator

Godeps/Godeps.json

@@ -308,8 +308,8 @@
 		},
 		{
 			"ImportPath": "github.com/blang/semver",
-			"Comment": "v3.0.1",
-			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
+			"Comment": "v3.5.0",
+			"Rev": "b38d23b8782a487059e8fc8773e9a5b228a77cb6"
 		},
 		{
 			"ImportPath": "github.com/boltdb/bolt",

test/e2e_node/system/BUILD

@@ -15,12 +15,14 @@ go_library(
         "docker_validator.go",
         "kernel_validator.go",
         "os_validator.go",
+        "package_validator.go",
         "report.go",
         "types.go",
         "validators.go",
     ],
     tags = ["automanaged"],
     deps = [
+        "//vendor/github.com/blang/semver:go_default_library",
         "//vendor/github.com/docker/engine-api/client:go_default_library",
         "//vendor/github.com/docker/engine-api/types:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
@@ -36,6 +38,7 @@ go_test(
         "docker_validator_test.go",
         "kernel_validator_test.go",
         "os_validator_test.go",
+        "package_validator_test.go",
     ],
     library = ":go_default_library",
     tags = ["automanaged"],

test/e2e_node/system/package_validator_test.go

+/*
+Copyright 2017 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 system
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestExtractUpstreamVersion(t *testing.T) {
+	for _, test := range []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "",
+			expected: "",
+		},
+		{
+			input:    "1.0.6",
+			expected: "1.0.6",
+		},
+		{
+			input:    "1:1.0.6",
+			expected: "1.0.6",
+		},
+		{
+			input:    "1.0.6-2ubuntu2.1",
+			expected: "1.0.6",
+		},
+		{
+			input:    "1:1.0.6-2ubuntu2.1",
+			expected: "1.0.6",
+		},
+	} {
+		got := extractUpstreamVersion(test.input)
+		if test.expected != got {
+			t.Errorf("extractUpstreamVersion(%q) = %q, want %q", test.input, got, test.expected)
+		}
+	}
+}
+
+func TestToSemVer(t *testing.T) {
+	for _, test := range []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "",
+			expected: "",
+		},
+		{
+			input:    "1.2.3",
+			expected: "1.2.3",
+		},
+		{
+			input:    "1.8.19p1",
+			expected: "1.8.19",
+		},
+		{
+			input:    "1.8.19.p1",
+			expected: "1.8.19",
+		},
+		{
+			input:    "p1",
+			expected: "",
+		},
+		{
+			input:    "1.18",
+			expected: "1.18.0",
+		},
+		{
+			input:    "481",
+			expected: "481.0.0",
+		},
+		{
+			input:    "2.0.10.4",
+			expected: "2.0.10",
+		},
+		{
+			input:    "03",
+			expected: "3.0.0",
+		},
+		{
+			input:    "2.02",
+			expected: "2.2.0",
+		},
+		{
+			input:    "8.0.0095",
+			expected: "8.0.95",
+		},
+	} {
+		got := toSemVer(test.input)
+		if test.expected != got {
+			t.Errorf("toSemVer(%q) = %q, want %q", test.input, got, test.expected)
+		}
+	}
+}
+
+func TestToSemVerRange(t *testing.T) {
+	for _, test := range []struct {
+		input    string
+		expected string
+	}{
+		{
+			input:    "",
+			expected: "",
+		},
+		{
+			input:    ">=1.0.0",
+			expected: ">=1.0.0",
+		},
+		{
+			input:    ">=1.0",
+			expected: ">=1.0.x",
+		},
+		{
+			input:    ">=1",
+			expected: ">=1.x",
+		},
+		{
+			input:    ">=1 || !2.3",
+			expected: ">=1.x || !2.3.x",
+		},
+		{
+			input:    ">1 || >3.1.0 !4.2",
+			expected: ">1.x || >3.1.0 !4.2.x",
+		},
+	} {
+		got := toSemVerRange(test.input)
+		if test.expected != got {
+			t.Errorf("toSemVerRange(%q) = %q, want %q", test.input, got, test.expected)
+		}
+	}
+}
+
+// testPackageManager implements the packageManager interface.
+type testPackageManager struct {
+	packageVersions map[string]string
+}
+
+func (m testPackageManager) getPackageVersion(packageName string) (string, error) {
+	if v, ok := m.packageVersions[packageName]; ok {
+		return v, nil
+	}
+	return "", fmt.Errorf("package %q does not exist", packageName)
+}
+
+func TestValidatePackageVersion(t *testing.T) {
+	testKernelRelease := "test-kernel-release"
+	manager := testPackageManager{
+		packageVersions: map[string]string{
+			"foo": "1.0.0",
+			"bar": "2.1.0",
+			"bar-" + testKernelRelease: "3.0.0",
+		},
+	}
+	v := &packageValidator{
+		reporter:      DefaultReporter,
+		kernelRelease: testKernelRelease,
+	}
+	for _, test := range []struct {
+		desc  string
+		specs []PackageSpec
+		err   error
+	}{
+		{
+			desc: "all packages meet the spec",
+			specs: []PackageSpec{
+				{Name: "foo", VersionRange: ">=1.0"},
+				{Name: "bar", VersionRange: ">=2.0 <= 3.0"},
+			},
+		},
+		{
+			desc: "package version does not meet the spec",
+			specs: []PackageSpec{
+				{Name: "foo", VersionRange: ">=1.0"},
+				{Name: "bar", VersionRange: ">=3.0"},
+			},
+			err: errors.New("package \"bar 2.1.0\" does not meet the spec \"bar (>=3.0)\""),
+		},
+		{
+			desc: "package not installed",
+			specs: []PackageSpec{
+				{Name: "baz"},
+			},
+			err: errors.New("package \"baz\" does not exist"),
+		},
+		{
+			desc: "use variable in package name",
+			specs: []PackageSpec{
+				{Name: "bar-${KERNEL_RELEASE}", VersionRange: ">=3.0"},
+			},
+		},
+	} {
+		_, err := v.validate(test.specs, manager)
+		if test.err == nil && err != nil {
+			t.Errorf("%s: v.validate(): err = %s", test.desc, err)
+		}
+		if test.err != nil {
+			if err == nil {
+				t.Errorf("%s: v.validate() is expected to fail.", test.desc)
+			} else if test.err.Error() != err.Error() {
+				t.Errorf("%s: v.validate(): err = %q, want = %q", test.desc, err, test.err)
+			}
+		}
+	}
+}
+
+func TestApplyPackageOverride(t *testing.T) {
+	for _, test := range []struct {
+		overrides []PackageSpecOverride
+		osDistro  string
+		specs     []PackageSpec
+		expected  []PackageSpec
+	}{
+		{
+			specs:    []PackageSpec{{Name: "foo", VersionRange: ">=1.0"}},
+			expected: []PackageSpec{{Name: "foo", VersionRange: ">=1.0"}},
+		},
+		{
+			osDistro: "ubuntu",
+			overrides: []PackageSpecOverride{
+				{
+					OSDistro:     "ubuntu",
+					Subtractions: []PackageSpec{{Name: "foo"}},
+					Additions:    []PackageSpec{{Name: "bar", VersionRange: ">=2.0"}},
+				},
+			},
+			specs:    []PackageSpec{{Name: "foo", VersionRange: ">=1.0"}},
+			expected: []PackageSpec{{Name: "bar", VersionRange: ">=2.0"}},
+		},
+		{
+			osDistro: "ubuntu",
+			overrides: []PackageSpecOverride{
+				{
+					OSDistro:     "debian",
+					Subtractions: []PackageSpec{{Name: "foo"}},
+				},
+			},
+			specs:    []PackageSpec{{Name: "foo", VersionRange: ">=1.0"}},
+			expected: []PackageSpec{{Name: "foo", VersionRange: ">=1.0"}},
+		},
+	} {
+		got := applyPackageSpecOverride(test.specs, test.overrides, test.osDistro)
+		if !reflect.DeepEqual(test.expected, got) {
+			t.Errorf("applyPackageSpecOverride(%+v, %+v, %s) = %+v, want = %+v", test.specs, test.overrides, test.osDistro, got, test.expected)
+		}
+	}
+}

test/e2e_node/system/types.go

@@ -65,6 +65,41 @@ type RuntimeSpec struct {
 	*DockerSpec
 }
 
+// PackageSpec defines the required packages and their versions.
+// PackageSpec is only supported on OS distro with Debian package manager.
+//
+// TODO(yguo0905): Support operator OR of multiple packages for the case where
+// either "foo (>=1.0)" or "bar (>=2.0)" is required.
+type PackageSpec struct {
+	// Name is the name of the package to be checked.
+	Name string
+	// VersionRange represents a range of versions that the package must
+	// satisfy. Note that the version requirement will not be enforced if
+	// the version range is empty. For example,
+	// - "" would match any versions but the package must be installed.
+	// - ">=1" would match "1.0.0", "1.0.1", "1.1.0", and "2.0".
+	// - ">1.0 <2.0" would match between both ranges, so "1.1.1" and "1.8.7"
+	//   but not "1.0.0" or "2.0.0".
+	// - "<2.0.0 || >=3.0.0" would match "1.0.0" and "3.0.0" but not "2.0.0".
+	VersionRange string
+	// Description explains the reason behind this package requirements.
+	Description string
+}
+
+// PackageSpecOverride defines the overrides on the PackageSpec for an OS
+// distro.
+type PackageSpecOverride struct {
+	// OSDistro identifies to which OS distro this override applies.
+	// Must be "ubuntu", "cos" or "coreos".
+	OSDistro string
+	// Subtractions is a list of package names that are excluded from the
+	// package spec.
+	Subtractions []PackageSpec
+	// Additions is a list of additional package requirements included the
+	// package spec.
+	Additions []PackageSpec
+}
+
 // SysSpec defines the requirement of supported system. Currently, it only contains
 // spec for OS, Kernel and Cgroups.
 type SysSpec struct {
@@ -76,6 +111,11 @@ type SysSpec struct {
 	Cgroups []string
 	// RuntimeSpec defines the spec for runtime.
 	RuntimeSpec RuntimeSpec
+	// PackageSpec defines the required packages and their versions.
+	PackageSpecs []PackageSpec
+	// PackageSpec defines the overrides of the required packages and their
+	// versions for an OS distro.
+	PackageSpecOverrides []PackageSpecOverride
 }
 
 // DefaultSysSpec is the default SysSpec.

test/e2e_node/system/validators.go

@@ -56,6 +56,7 @@ func ValidateDefault(runtime string) (error, error) {
 		&OSValidator{Reporter: DefaultReporter},
 		&KernelValidator{Reporter: DefaultReporter},
 		&CgroupsValidator{Reporter: DefaultReporter},
+		&packageValidator{reporter: DefaultReporter},
 	}
 	// Docker-specific validators.
 	var dockerValidators = []Validator{

vendor/github.com/blang/semver/BUILD

@@ -11,6 +11,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "json.go",
+        "range.go",
         "semver.go",
         "sort.go",
         "sql.go",

vendor/github.com/blang/semver/README.md

@@ -40,10 +40,52 @@ Features
 - Comparator-like comparisons
 - Compare Helper Methods
 - InPlace manipulation
+- Ranges `>=1.0.0 <2.0.0 || >=3.0.0 !3.0.1-beta.1`
 - Sortable (implements sort.Interface)
 - database/sql compatible (sql.Scanner/Valuer)
 - encoding/json compatible (json.Marshaler/Unmarshaler)
 
+Ranges
+------
+
+A `Range` is a set of conditions which specify which versions satisfy the range.
+
+A condition is composed of an operator and a version. The supported operators are:
+
+- `<1.0.0` Less than `1.0.0`
+- `<=1.0.0` Less than or equal to `1.0.0`
+- `>1.0.0` Greater than `1.0.0`
+- `>=1.0.0` Greater than or equal to `1.0.0`
+- `1.0.0`, `=1.0.0`, `==1.0.0` Equal to `1.0.0`
+- `!1.0.0`, `!=1.0.0` Not equal to `1.0.0`. Excludes version `1.0.0`.
+
+A `Range` can link multiple `Ranges` separated by space:
+
+Ranges can be linked by logical AND:
+
+  - `>1.0.0 <2.0.0` would match between both ranges, so `1.1.1` and `1.8.7` but not `1.0.0` or `2.0.0`
+  - `>1.0.0 <3.0.0 !2.0.3-beta.2` would match every version between `1.0.0` and `3.0.0` except `2.0.3-beta.2`
+
+Ranges can also be linked by logical OR:
+
+  - `<2.0.0 || >=3.0.0` would match `1.x.x` and `3.x.x` but not `2.x.x`
+
+AND has a higher precedence than OR. It's not possible to use brackets.
+
+Ranges can be combined by both AND and OR
+
+  - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1`
+
+Range usage:
+
+```
+v, err := semver.Parse("1.2.3")
+range, err := semver.ParseRange(">1.0.0 <2.0.0 || >=3.0.0")
+if range(v) {
+    //valid
+}
+
+```
 
 Example
 -----
@@ -103,23 +145,30 @@ if err != nil {
 }
 ```
 
+
 Benchmarks
 -----
 
-    BenchmarkParseSimple         5000000      328    ns/op    49 B/op   1 allocs/op
-    BenchmarkParseComplex        1000000     2105    ns/op   263 B/op   7 allocs/op
-    BenchmarkParseAverage        1000000     1301    ns/op   168 B/op   4 allocs/op
-    BenchmarkStringSimple       10000000      130    ns/op     5 B/op   1 allocs/op
-    BenchmarkStringLarger        5000000      280    ns/op    32 B/op   2 allocs/op
-    BenchmarkStringComplex       3000000      512    ns/op    80 B/op   3 allocs/op
-    BenchmarkStringAverage       5000000      387    ns/op    47 B/op   2 allocs/op
-    BenchmarkValidateSimple    500000000        7.92 ns/op     0 B/op   0 allocs/op
-    BenchmarkValidateComplex     2000000      923    ns/op     0 B/op   0 allocs/op
-    BenchmarkValidateAverage     5000000      452    ns/op     0 B/op   0 allocs/op
-    BenchmarkCompareSimple     100000000       11.2  ns/op     0 B/op   0 allocs/op
-    BenchmarkCompareComplex     50000000       40.9  ns/op     0 B/op   0 allocs/op
-    BenchmarkCompareAverage     50000000       43.8  ns/op     0 B/op   0 allocs/op
-    BenchmarkSort                5000000      436    ns/op   259 B/op   2 allocs/op
+    BenchmarkParseSimple-4           5000000    390    ns/op    48 B/op   1 allocs/op
+    BenchmarkParseComplex-4          1000000   1813    ns/op   256 B/op   7 allocs/op
+    BenchmarkParseAverage-4          1000000   1171    ns/op   163 B/op   4 allocs/op
+    BenchmarkStringSimple-4         20000000    119    ns/op    16 B/op   1 allocs/op
+    BenchmarkStringLarger-4         10000000    206    ns/op    32 B/op   2 allocs/op
+    BenchmarkStringComplex-4         5000000    324    ns/op    80 B/op   3 allocs/op
+    BenchmarkStringAverage-4         5000000    273    ns/op    53 B/op   2 allocs/op
+    BenchmarkValidateSimple-4      200000000      9.33 ns/op     0 B/op   0 allocs/op
+    BenchmarkValidateComplex-4       3000000    469    ns/op     0 B/op   0 allocs/op
+    BenchmarkValidateAverage-4       5000000    256    ns/op     0 B/op   0 allocs/op
+    BenchmarkCompareSimple-4       100000000     11.8  ns/op     0 B/op   0 allocs/op
+    BenchmarkCompareComplex-4       50000000     30.8  ns/op     0 B/op   0 allocs/op
+    BenchmarkCompareAverage-4       30000000     41.5  ns/op     0 B/op   0 allocs/op
+    BenchmarkSort-4                  3000000    419    ns/op   256 B/op   2 allocs/op
+    BenchmarkRangeParseSimple-4      2000000    850    ns/op   192 B/op   5 allocs/op
+    BenchmarkRangeParseAverage-4     1000000   1677    ns/op   400 B/op  10 allocs/op
+    BenchmarkRangeParseComplex-4      300000   5214    ns/op  1440 B/op  30 allocs/op
+    BenchmarkRangeMatchSimple-4     50000000     25.6  ns/op     0 B/op   0 allocs/op
+    BenchmarkRangeMatchAverage-4    30000000     56.4  ns/op     0 B/op   0 allocs/op
+    BenchmarkRangeMatchComplex-4    10000000    153    ns/op     0 B/op   0 allocs/op
 
 See benchmark cases at [semver_test.go](semver_test.go)
 

vendor/github.com/blang/semver/package.json

+{
+  "author": "blang",
+  "bugs": {
+    "URL": "https://github.com/blang/semver/issues",
+    "url": "https://github.com/blang/semver/issues"
+  },
+  "gx": {
+    "dvcsimport": "github.com/blang/semver"
+  },
+  "gxVersion": "0.10.0",
+  "language": "go",
+  "license": "MIT",
+  "name": "semver",
+  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
+  "version": "3.4.0"
+}
+

vendor/github.com/blang/semver/semver.go

@@ -200,6 +200,29 @@ func Make(s string) (Version, error) {
 	return Parse(s)
 }
 
+// ParseTolerant allows for certain version specifications that do not strictly adhere to semver
+// specs to be parsed by this library. It does so by normalizing versions before passing them to
+// Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions
+// with only major and minor components specified
+func ParseTolerant(s string) (Version, error) {
+	s = strings.TrimSpace(s)
+	s = strings.TrimPrefix(s, "v")
+
+	// Split into major.minor.(patch+pr+meta)
+	parts := strings.SplitN(s, ".", 3)
+	if len(parts) < 3 {
+		if strings.ContainsAny(parts[len(parts)-1], "+-") {
+			return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data")
+		}
+		for len(parts) < 3 {
+			parts = append(parts, "0")
+		}
+		s = strings.Join(parts, ".")
+	}
+
+	return Parse(s)
+}
+
 // Parse parses version string and returns a validated Version or error
 func Parse(s string) (Version, error) {
 	if len(s) == 0 {