Rename kubeproxy config pkg and group.

pkg/proxy/apis/kubeproxyconfig/doc.go

@@ -16,4 +16,4 @@ limitations under the License.
 
 // +k8s:deepcopy-gen=package,register
 
-package proxyconfig // import "k8s.io/kubernetes/pkg/proxy/apis/proxyconfig"
+package kubeproxyconfig // import "k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig"

pkg/proxy/apis/kubeproxyconfig/register.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package proxyconfig
+package kubeproxyconfig
 
 import (
 	"k8s.io/apimachinery/pkg/runtime"
@@ -27,7 +27,7 @@ var (
 )
 
 // GroupName is the group name use in this package
-const GroupName = "kubeproxy.k8s.io"
+const GroupName = "kubeproxyconfig.k8s.io"
 
 // SchemeGroupVersion is group version used to register these objects
 var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

pkg/proxy/apis/kubeproxyconfig/scheme/scheme.go

@@ -21,8 +21,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/kubernetes/pkg/proxy/apis/proxyconfig"
-	"k8s.io/kubernetes/pkg/proxy/apis/proxyconfig/v1alpha1"
+	"k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig"
+	"k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig/v1alpha1"
 )
 
 var (
@@ -41,5 +41,5 @@ func init() {
 // AddToScheme adds the types of this group into the given scheme.
 func AddToScheme(scheme *runtime.Scheme) {
 	v1alpha1.AddToScheme(scheme)
-	proxyconfig.AddToScheme(scheme)
+	kubeproxyconfig.AddToScheme(scheme)
 }

pkg/proxy/apis/kubeproxyconfig/types.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package proxyconfig
+package kubeproxyconfig
 
 import (
 	"fmt"

pkg/proxy/apis/kubeproxyconfig/v1alpha1/doc.go

@@ -15,8 +15,8 @@ limitations under the License.
 */
 
 // +k8s:deepcopy-gen=package,register
-// +k8s:conversion-gen=k8s.io/kubernetes/pkg/proxy/apis/proxyconfig
+// +k8s:conversion-gen=k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig
 // +k8s:openapi-gen=true
 // +k8s:defaulter-gen=TypeMeta
 
-package v1alpha1 // import "k8s.io/kubernetes/pkg/proxy/apis/proxyconfig/v1alpha1"
+package v1alpha1 // import "k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig/v1alpha1"

pkg/proxy/apis/kubeproxyconfig/v1alpha1/register.go

@@ -22,7 +22,7 @@ import (
 )
 
 // GroupName is the group name use in this package
-const GroupName = "kubeproxy.k8s.io"
+const GroupName = "kubeproxyconfig.k8s.io"
 
 // SchemeGroupVersion is group version used to register these objects
 var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}

pkg/proxy/apis/kubeproxyconfig/validation/validation.go

@@ -25,11 +25,11 @@ import (
 	utilnet "k8s.io/apimachinery/pkg/util/net"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	apivalidation "k8s.io/kubernetes/pkg/api/validation"
-	"k8s.io/kubernetes/pkg/proxy/apis/proxyconfig"
+	"k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig"
 )
 
 // Validate validates the configuration of kube-proxy
-func Validate(config *proxyconfig.KubeProxyConfiguration) field.ErrorList {
+func Validate(config *kubeproxyconfig.KubeProxyConfiguration) field.ErrorList {
 	allErrs := field.ErrorList{}
 
 	newPath := field.NewPath("KubeProxyConfiguration")
@@ -38,7 +38,7 @@ func Validate(config *proxyconfig.KubeProxyConfiguration) field.ErrorList {
 	allErrs = append(allErrs, validateKubeProxyConntrackConfiguration(config.Conntrack, newPath.Child("KubeProxyConntrackConfiguration"))...)
 	allErrs = append(allErrs, validateProxyMode(config.Mode, newPath.Child("Mode"))...)
 	allErrs = append(allErrs, validateClientConnectionConfiguration(config.ClientConnection, newPath.Child("ClientConnection"))...)
-	allErrs = append(allErrs, validateIPVSSchedulerMethod(proxyconfig.IPVSSchedulerMethod(config.IPVS.Scheduler), newPath.Child("KubeProxyIPVSConfiguration").Child("Scheduler"))...)
+	allErrs = append(allErrs, validateIPVSSchedulerMethod(kubeproxyconfig.IPVSSchedulerMethod(config.IPVS.Scheduler), newPath.Child("KubeProxyIPVSConfiguration").Child("Scheduler"))...)
 
 	if config.OOMScoreAdj != nil && (*config.OOMScoreAdj < -1000 || *config.OOMScoreAdj > 1000) {
 		allErrs = append(allErrs, field.Invalid(newPath.Child("OOMScoreAdj"), *config.OOMScoreAdj, "must be within the range [-1000, 1000]"))
@@ -72,7 +72,7 @@ func Validate(config *proxyconfig.KubeProxyConfiguration) field.ErrorList {
 	return allErrs
 }
 
-func validateKubeProxyIPTablesConfiguration(config proxyconfig.KubeProxyIPTablesConfiguration, fldPath *field.Path) field.ErrorList {
+func validateKubeProxyIPTablesConfiguration(config kubeproxyconfig.KubeProxyIPTablesConfiguration, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 
 	if config.MasqueradeBit != nil && (*config.MasqueradeBit < 0 || *config.MasqueradeBit > 31) {
@@ -90,7 +90,7 @@ func validateKubeProxyIPTablesConfiguration(config proxyconfig.KubeProxyIPTables
 	return allErrs
 }
 
-func validateKubeProxyConntrackConfiguration(config proxyconfig.KubeProxyConntrackConfiguration, fldPath *field.Path) field.ErrorList {
+func validateKubeProxyConntrackConfiguration(config kubeproxyconfig.KubeProxyConntrackConfiguration, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 
 	if config.Max < 0 {
@@ -116,22 +116,22 @@ func validateKubeProxyConntrackConfiguration(config proxyconfig.KubeProxyConntra
 	return allErrs
 }
 
-func validateProxyMode(mode proxyconfig.ProxyMode, fldPath *field.Path) field.ErrorList {
+func validateProxyMode(mode kubeproxyconfig.ProxyMode, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 	switch mode {
-	case proxyconfig.ProxyModeUserspace:
-	case proxyconfig.ProxyModeIPTables:
-	case proxyconfig.ProxyModeIPVS:
+	case kubeproxyconfig.ProxyModeUserspace:
+	case kubeproxyconfig.ProxyModeIPTables:
+	case kubeproxyconfig.ProxyModeIPVS:
 	case "":
 	default:
-		modes := []string{string(proxyconfig.ProxyModeUserspace), string(proxyconfig.ProxyModeIPTables), string(proxyconfig.ProxyModeIPVS)}
+		modes := []string{string(kubeproxyconfig.ProxyModeUserspace), string(kubeproxyconfig.ProxyModeIPTables), string(kubeproxyconfig.ProxyModeIPVS)}
 		errMsg := fmt.Sprintf("must be %s or blank (blank means the best-available proxy (currently iptables)", strings.Join(modes, ","))
 		allErrs = append(allErrs, field.Invalid(fldPath.Child("ProxyMode"), string(mode), errMsg))
 	}
 	return allErrs
 }
 
-func validateClientConnectionConfiguration(config proxyconfig.ClientConnectionConfiguration, fldPath *field.Path) field.ErrorList {
+func validateClientConnectionConfiguration(config kubeproxyconfig.ClientConnectionConfiguration, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 	allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(config.Burst), fldPath.Child("Burst"))...)
 	return allErrs
@@ -159,18 +159,18 @@ func validateHostPort(input string, fldPath *field.Path) field.ErrorList {
 	return allErrs
 }
 
-func validateIPVSSchedulerMethod(scheduler proxyconfig.IPVSSchedulerMethod, fldPath *field.Path) field.ErrorList {
-	supportedMethod := []proxyconfig.IPVSSchedulerMethod{
-		proxyconfig.RoundRobin,
-		proxyconfig.WeightedRoundRobin,
-		proxyconfig.LeastConnection,
-		proxyconfig.WeightedLeastConnection,
-		proxyconfig.LocalityBasedLeastConnection,
-		proxyconfig.LocalityBasedLeastConnectionWithReplication,
-		proxyconfig.SourceHashing,
-		proxyconfig.DestinationHashing,
-		proxyconfig.ShortestExpectedDelay,
-		proxyconfig.NeverQueue,
+func validateIPVSSchedulerMethod(scheduler kubeproxyconfig.IPVSSchedulerMethod, fldPath *field.Path) field.ErrorList {
+	supportedMethod := []kubeproxyconfig.IPVSSchedulerMethod{
+		kubeproxyconfig.RoundRobin,
+		kubeproxyconfig.WeightedRoundRobin,
+		kubeproxyconfig.LeastConnection,
+		kubeproxyconfig.WeightedLeastConnection,
+		kubeproxyconfig.LocalityBasedLeastConnection,
+		kubeproxyconfig.LocalityBasedLeastConnectionWithReplication,
+		kubeproxyconfig.SourceHashing,
+		kubeproxyconfig.DestinationHashing,
+		kubeproxyconfig.ShortestExpectedDelay,
+		kubeproxyconfig.NeverQueue,
 		"",
 	}
 	allErrs := field.ErrorList{}

pkg/proxy/apis/kubeproxyconfig/validation/validation_test.go

@@ -23,11 +23,11 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/validation/field"
-	"k8s.io/kubernetes/pkg/proxy/apis/proxyconfig"
+	"k8s.io/kubernetes/pkg/proxy/apis/kubeproxyconfig"
 )
 
 func TestValidateKubeProxyConfiguration(t *testing.T) {
-	successCases := []proxyconfig.KubeProxyConfiguration{
+	successCases := []kubeproxyconfig.KubeProxyConfiguration{
 		{
 			BindAddress:        "192.168.59.103",
 			HealthzBindAddress: "0.0.0.0:10256",
@@ -35,12 +35,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			ClusterCIDR:        "192.168.59.0/24",
 			UDPIdleTimeout:     metav1.Duration{Duration: 1 * time.Second},
 			ConfigSyncPeriod:   metav1.Duration{Duration: 1 * time.Second},
-			IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+			IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 				MasqueradeAll: true,
 				SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 				MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 			},
-			Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+			Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(2),
 				MaxPerCore: int32(1),
 				Min:        int32(1),
@@ -57,11 +57,11 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 	}
 
 	errorCases := []struct {
-		config proxyconfig.KubeProxyConfiguration
+		config kubeproxyconfig.KubeProxyConfiguration
 		msg    string
 	}{
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				// only BindAddress is invalid
 				BindAddress:        "10.10.12.11:2000",
 				HealthzBindAddress: "0.0.0.0:10256",
@@ -69,12 +69,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				ClusterCIDR:        "192.168.59.0/24",
 				UDPIdleTimeout:     metav1.Duration{Duration: 1 * time.Second},
 				ConfigSyncPeriod:   metav1.Duration{Duration: 1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -85,7 +85,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			msg: "not a valid textual representation of an IP address",
 		},
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				BindAddress: "10.10.12.11",
 				// only HealthzBindAddress is invalid
 				HealthzBindAddress: "0.0.0.0",
@@ -93,12 +93,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				ClusterCIDR:        "192.168.59.0/24",
 				UDPIdleTimeout:     metav1.Duration{Duration: 1 * time.Second},
 				ConfigSyncPeriod:   metav1.Duration{Duration: 1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -109,7 +109,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			msg: "must be IP:port",
 		},
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				BindAddress:        "10.10.12.11",
 				HealthzBindAddress: "0.0.0.0:12345",
 				// only MetricsBindAddress is invalid
@@ -117,12 +117,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				ClusterCIDR:        "192.168.59.0/24",
 				UDPIdleTimeout:     metav1.Duration{Duration: 1 * time.Second},
 				ConfigSyncPeriod:   metav1.Duration{Duration: 1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -133,7 +133,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			msg: "must be IP:port",
 		},
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				BindAddress:        "10.10.12.11",
 				HealthzBindAddress: "0.0.0.0:12345",
 				MetricsBindAddress: "127.0.0.1:10249",
@@ -141,12 +141,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				ClusterCIDR:      "192.168.59.0",
 				UDPIdleTimeout:   metav1.Duration{Duration: 1 * time.Second},
 				ConfigSyncPeriod: metav1.Duration{Duration: 1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -157,7 +157,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			msg: "must be a valid CIDR block (e.g. 10.100.0.0/16)",
 		},
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				BindAddress:        "10.10.12.11",
 				HealthzBindAddress: "0.0.0.0:12345",
 				MetricsBindAddress: "127.0.0.1:10249",
@@ -165,12 +165,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				// only UDPIdleTimeout is invalid
 				UDPIdleTimeout:   metav1.Duration{Duration: -1 * time.Second},
 				ConfigSyncPeriod: metav1.Duration{Duration: 1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -181,7 +181,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 			msg: "must be greater than 0",
 		},
 		{
-			config: proxyconfig.KubeProxyConfiguration{
+			config: kubeproxyconfig.KubeProxyConfiguration{
 				BindAddress:        "10.10.12.11",
 				HealthzBindAddress: "0.0.0.0:12345",
 				MetricsBindAddress: "127.0.0.1:10249",
@@ -189,12 +189,12 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 				UDPIdleTimeout:     metav1.Duration{Duration: 1 * time.Second},
 				// only ConfigSyncPeriod is invalid
 				ConfigSyncPeriod: metav1.Duration{Duration: -1 * time.Second},
-				IPTables: proxyconfig.KubeProxyIPTablesConfiguration{
+				IPTables: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 					MasqueradeAll: true,
 					SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
 					MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
 				},
-				Conntrack: proxyconfig.KubeProxyConntrackConfiguration{
+				Conntrack: kubeproxyconfig.KubeProxyConntrackConfiguration{
 					Max:        int32(2),
 					MaxPerCore: int32(1),
 					Min:        int32(1),
@@ -217,7 +217,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
 
 func TestValidateKubeProxyIPTablesConfiguration(t *testing.T) {
 	valid := int32(5)
-	successCases := []proxyconfig.KubeProxyIPTablesConfiguration{
+	successCases := []kubeproxyconfig.KubeProxyIPTablesConfiguration{
 		{
 			MasqueradeAll: true,
 			SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
@@ -239,11 +239,11 @@ func TestValidateKubeProxyIPTablesConfiguration(t *testing.T) {
 
 	invalid := int32(-10)
 	errorCases := []struct {
-		config proxyconfig.KubeProxyIPTablesConfiguration
+		config kubeproxyconfig.KubeProxyIPTablesConfiguration
 		msg    string
 	}{
 		{
-			config: proxyconfig.KubeProxyIPTablesConfiguration{
+			config: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 				MasqueradeAll: true,
 				SyncPeriod:    metav1.Duration{Duration: -5 * time.Second},
 				MinSyncPeriod: metav1.Duration{Duration: 2 * time.Second},
@@ -251,7 +251,7 @@ func TestValidateKubeProxyIPTablesConfiguration(t *testing.T) {
 			msg: "must be greater than 0",
 		},
 		{
-			config: proxyconfig.KubeProxyIPTablesConfiguration{
+			config: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 				MasqueradeBit: &valid,
 				MasqueradeAll: true,
 				SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
@@ -260,7 +260,7 @@ func TestValidateKubeProxyIPTablesConfiguration(t *testing.T) {
 			msg: "must be greater than or equal to 0",
 		},
 		{
-			config: proxyconfig.KubeProxyIPTablesConfiguration{
+			config: kubeproxyconfig.KubeProxyIPTablesConfiguration{
 				MasqueradeBit: &invalid,
 				MasqueradeAll: true,
 				SyncPeriod:    metav1.Duration{Duration: 5 * time.Second},
@@ -280,7 +280,7 @@ func TestValidateKubeProxyIPTablesConfiguration(t *testing.T) {
 }
 
 func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
-	successCases := []proxyconfig.KubeProxyConntrackConfiguration{
+	successCases := []kubeproxyconfig.KubeProxyConntrackConfiguration{
 		{
 			Max:        int32(2),
 			MaxPerCore: int32(1),
@@ -304,11 +304,11 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 	}
 
 	errorCases := []struct {
-		config proxyconfig.KubeProxyConntrackConfiguration
+		config kubeproxyconfig.KubeProxyConntrackConfiguration
 		msg    string
 	}{
 		{
-			config: proxyconfig.KubeProxyConntrackConfiguration{
+			config: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(-1),
 				MaxPerCore: int32(1),
 				Min:        int32(1),
@@ -318,7 +318,7 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 			msg: "must be greater than or equal to 0",
 		},
 		{
-			config: proxyconfig.KubeProxyConntrackConfiguration{
+			config: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(2),
 				MaxPerCore: int32(-1),
 				Min:        int32(1),
@@ -328,7 +328,7 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 			msg: "must be greater than or equal to 0",
 		},
 		{
-			config: proxyconfig.KubeProxyConntrackConfiguration{
+			config: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(2),
 				MaxPerCore: int32(1),
 				Min:        int32(-1),
@@ -338,7 +338,7 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 			msg: "must be greater than or equal to 0",
 		},
 		{
-			config: proxyconfig.KubeProxyConntrackConfiguration{
+			config: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(4),
 				MaxPerCore: int32(1),
 				Min:        int32(3),
@@ -348,7 +348,7 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 			msg: "must be greater than 0",
 		},
 		{
-			config: proxyconfig.KubeProxyConntrackConfiguration{
+			config: kubeproxyconfig.KubeProxyConntrackConfiguration{
 				Max:        int32(4),
 				MaxPerCore: int32(1),
 				Min:        int32(3),
@@ -371,11 +371,11 @@ func TestValidateKubeProxyConntrackConfiguration(t *testing.T) {
 func TestValidateProxyMode(t *testing.T) {
 	newPath := field.NewPath("KubeProxyConfiguration")
 
-	successCases := []proxyconfig.ProxyMode{
-		proxyconfig.ProxyModeUserspace,
-		proxyconfig.ProxyModeIPTables,
-		proxyconfig.ProxyModeIPVS,
-		proxyconfig.ProxyMode(""),
+	successCases := []kubeproxyconfig.ProxyMode{
+		kubeproxyconfig.ProxyModeUserspace,
+		kubeproxyconfig.ProxyModeIPTables,
+		kubeproxyconfig.ProxyModeIPVS,
+		kubeproxyconfig.ProxyMode(""),
 	}
 
 	for _, successCase := range successCases {
@@ -385,11 +385,11 @@ func TestValidateProxyMode(t *testing.T) {
 	}
 
 	errorCases := []struct {
-		mode proxyconfig.ProxyMode
+		mode kubeproxyconfig.ProxyMode
 		msg  string
 	}{
 		{
-			mode: proxyconfig.ProxyMode("non-existing"),
+			mode: kubeproxyconfig.ProxyMode("non-existing"),
 			msg:  "or blank (blank means the best-available proxy (currently iptables)",
 		},
 	}
@@ -406,7 +406,7 @@ func TestValidateProxyMode(t *testing.T) {
 func TestValidateClientConnectionConfiguration(t *testing.T) {
 	newPath := field.NewPath("KubeProxyConfiguration")
 
-	successCases := []proxyconfig.ClientConnectionConfiguration{
+	successCases := []kubeproxyconfig.ClientConnectionConfiguration{
 		{
 			Burst: 0,
 		},
@@ -422,11 +422,11 @@ func TestValidateClientConnectionConfiguration(t *testing.T) {
 	}
 
 	errorCases := []struct {
-		ccc proxyconfig.ClientConnectionConfiguration
+		ccc kubeproxyconfig.ClientConnectionConfiguration
 		msg string
 	}{
 		{
-			ccc: proxyconfig.ClientConnectionConfiguration{Burst: -5},
+			ccc: kubeproxyconfig.ClientConnectionConfiguration{Burst: -5},
 			msg: "must be greater than or equal to 0",
 		},
 	}
@@ -493,17 +493,17 @@ func TestValidateHostPort(t *testing.T) {
 func TestValidateIPVSSchedulerMethod(t *testing.T) {
 	newPath := field.NewPath("KubeProxyConfiguration")
 
-	successCases := []proxyconfig.IPVSSchedulerMethod{
-		proxyconfig.RoundRobin,
-		proxyconfig.WeightedRoundRobin,
-		proxyconfig.LeastConnection,
-		proxyconfig.WeightedLeastConnection,
-		proxyconfig.LocalityBasedLeastConnection,
-		proxyconfig.LocalityBasedLeastConnectionWithReplication,
-		proxyconfig.SourceHashing,
-		proxyconfig.DestinationHashing,
-		proxyconfig.ShortestExpectedDelay,
-		proxyconfig.NeverQueue,
+	successCases := []kubeproxyconfig.IPVSSchedulerMethod{
+		kubeproxyconfig.RoundRobin,
+		kubeproxyconfig.WeightedRoundRobin,
+		kubeproxyconfig.LeastConnection,
+		kubeproxyconfig.WeightedLeastConnection,
+		kubeproxyconfig.LocalityBasedLeastConnection,
+		kubeproxyconfig.LocalityBasedLeastConnectionWithReplication,
+		kubeproxyconfig.SourceHashing,
+		kubeproxyconfig.DestinationHashing,
+		kubeproxyconfig.ShortestExpectedDelay,
+		kubeproxyconfig.NeverQueue,
 		"",
 	}
 
@@ -514,11 +514,11 @@ func TestValidateIPVSSchedulerMethod(t *testing.T) {
 	}
 
 	errorCases := []struct {
-		mode proxyconfig.IPVSSchedulerMethod
+		mode kubeproxyconfig.IPVSSchedulerMethod
 		msg  string
 	}{
 		{
-			mode: proxyconfig.IPVSSchedulerMethod("non-existing"),
+			mode: kubeproxyconfig.IPVSSchedulerMethod("non-existing"),
 			msg:  "blank means the default algorithm method (currently rr)",
 		},
 	}