Port iptables code to pkg/util/version, don't use semvers

pkg/proxy/iptables/BUILD

@@ -25,7 +25,7 @@ go_library(
         "//pkg/util/sets:go_default_library",
         "//pkg/util/slice:go_default_library",
         "//pkg/util/sysctl:go_default_library",
-        "//vendor:github.com/coreos/go-semver/semver",
+        "//pkg/util/version:go_default_library",
         "//vendor:github.com/davecgh/go-spew/spew",
         "//vendor:github.com/golang/glog",
     ],

pkg/proxy/iptables/proxier.go

@@ -32,7 +32,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/coreos/go-semver/semver"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
@@ -47,6 +46,7 @@ import (
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/slice"
 	utilsysctl "k8s.io/kubernetes/pkg/util/sysctl"
+	utilversion "k8s.io/kubernetes/pkg/util/version"
 )
 
 const (
@@ -93,20 +93,19 @@ type KernelCompatTester interface {
 // an error if it fails to get the iptables version without error, in which
 // case it will also return false.
 func CanUseIPTablesProxier(iptver IPTablesVersioner, kcompat KernelCompatTester) (bool, error) {
-	minVersion, err := semver.NewVersion(iptablesMinVersion)
+	minVersion, err := utilversion.ParseGeneric(iptablesMinVersion)
 	if err != nil {
 		return false, err
 	}
-	// returns "X.Y.Z"
 	versionString, err := iptver.GetVersion()
 	if err != nil {
 		return false, err
 	}
-	version, err := semver.NewVersion(versionString)
+	version, err := utilversion.ParseGeneric(versionString)
 	if err != nil {
 		return false, err
 	}
-	if version.LessThan(*minVersion) {
+	if version.LessThan(minVersion) {
 		return false, nil
 	}
 

pkg/util/iptables/BUILD

@@ -20,7 +20,7 @@ go_library(
         "//pkg/util/dbus:go_default_library",
         "//pkg/util/exec:go_default_library",
         "//pkg/util/sets:go_default_library",
-        "//vendor:github.com/coreos/go-semver/semver",
+        "//pkg/util/version:go_default_library",
         "//vendor:github.com/godbus/dbus",
         "//vendor:github.com/golang/glog",
     ],

pkg/util/iptables/iptables.go

@@ -23,12 +23,12 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/coreos/go-semver/semver"
 	godbus "github.com/godbus/dbus"
 	"github.com/golang/glog"
 	utildbus "k8s.io/kubernetes/pkg/util/dbus"
 	utilexec "k8s.io/kubernetes/pkg/util/exec"
 	"k8s.io/kubernetes/pkg/util/sets"
+	utilversion "k8s.io/kubernetes/pkg/util/version"
 )
 
 type RulePosition string
@@ -40,7 +40,7 @@ const (
 
 // An injectable interface for running iptables commands.  Implementations must be goroutine-safe.
 type Interface interface {
-	// GetVersion returns the "X.Y.Z" semver string for iptables.
+	// GetVersion returns the "X.Y.Z" version string for iptables.
 	GetVersion() (string, error)
 	// EnsureChain checks if the specified chain exists and, if not, creates it.  If the chain existed, return true.
 	EnsureChain(table Table, chain Chain) (bool, error)
@@ -462,45 +462,42 @@ func makeFullArgs(table Table, chain Chain, args ...string) []string {
 
 // Checks if iptables has the "-C" flag
 func getIPTablesHasCheckCommand(vstring string) bool {
-	minVersion, err := semver.NewVersion(MinCheckVersion)
+	minVersion, err := utilversion.ParseGeneric(MinCheckVersion)
 	if err != nil {
 		glog.Errorf("MinCheckVersion (%s) is not a valid version string: %v", MinCheckVersion, err)
 		return true
 	}
-	version, err := semver.NewVersion(vstring)
+	version, err := utilversion.ParseGeneric(vstring)
 	if err != nil {
 		glog.Errorf("vstring (%s) is not a valid version string: %v", vstring, err)
 		return true
 	}
-	if version.LessThan(*minVersion) {
+	return version.AtLeast(minVersion)
-		return false
-	}
-	return true
 }
 
 // Checks if iptables version has a "wait" flag
 func getIPTablesWaitFlag(vstring string) []string {
-	version, err := semver.NewVersion(vstring)
+	version, err := utilversion.ParseGeneric(vstring)
 	if err != nil {
 		glog.Errorf("vstring (%s) is not a valid version string: %v", vstring, err)
 		return nil
 	}
 
-	minVersion, err := semver.NewVersion(MinWaitVersion)
+	minVersion, err := utilversion.ParseGeneric(MinWaitVersion)
 	if err != nil {
 		glog.Errorf("MinWaitVersion (%s) is not a valid version string: %v", MinWaitVersion, err)
 		return nil
 	}
-	if version.LessThan(*minVersion) {
+	if version.LessThan(minVersion) {
 		return nil
 	}
 
-	minVersion, err = semver.NewVersion(MinWait2Version)
+	minVersion, err = utilversion.ParseGeneric(MinWait2Version)
 	if err != nil {
 		glog.Errorf("MinWait2Version (%s) is not a valid version string: %v", MinWait2Version, err)
 		return nil
 	}
-	if version.LessThan(*minVersion) {
+	if version.LessThan(minVersion) {
 		return []string{"-w"}
 	} else {
 		return []string{"-w2"}
@@ -515,7 +512,7 @@ func getIPTablesVersionString(exec utilexec.Interface) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	versionMatcher := regexp.MustCompile("v([0-9]+\\.[0-9]+\\.[0-9]+)")
+	versionMatcher := regexp.MustCompile("v([0-9]+(\\.[0-9]+)+)")
 	match := versionMatcher.FindStringSubmatch(string(bytes))
 	if match == nil {
 		return "", fmt.Errorf("no iptables version found in string: %s", bytes)