@@ -23,6 +23,7 @@ import (

 	utildbus "k8s.io/kubernetes/pkg/util/dbus"

 	kexec "k8s.io/kubernetes/pkg/util/exec"

 	utiliptables "k8s.io/kubernetes/pkg/util/iptables"

+	utilnet "k8s.io/kubernetes/pkg/util/net"

 	cmdutil "github.com/openshift/origin/pkg/cmd/util"

 	dockerutil "github.com/openshift/origin/pkg/cmd/util/docker"

@@ -193,10 +194,13 @@ func (c *NodeConfig) RunSDN() {

 // RunProxy starts the proxy

 func (c *NodeConfig) RunProxy() {

 	protocol := utiliptables.ProtocolIpv4

-	if c.ProxyConfig.BindAddress.To4() == nil {

+	bindAddr := net.ParseIP(c.ProxyConfig.BindAddress)

+	if bindAddr.To4() == nil {

 		protocol = utiliptables.ProtocolIpv6

 	}

+	portRange := utilnet.ParsePortRangeOrDie(c.ProxyConfig.PortRange)

+

 	eventBroadcaster := record.NewBroadcaster()

 	eventBroadcaster.StartRecordingToSink(c.Client.Events(""))

 	recorder := eventBroadcaster.NewRecorder(kapi.EventSource{Component: "kube-proxy", Host: c.KubeletConfig.NodeName})

@@ -208,10 +212,10 @@ func (c *NodeConfig) RunProxy() {

 	var proxier proxy.ProxyProvider

 	var endpointsHandler pconfig.EndpointsConfigHandler

-	switch c.ProxyConfig.ProxyMode {

+	switch c.ProxyConfig.Mode {

 	case "iptables":

 		glog.V(0).Info("Using iptables Proxier.")

-		proxierIptables, err := iptables.NewProxier(iptInterface, exec, c.ProxyConfig.IptablesSyncPeriod, c.ProxyConfig.MasqueradeAll)

+		proxierIptables, err := iptables.NewProxier(iptInterface, exec, c.ProxyConfig.IPTablesSyncPeriod.Duration, c.ProxyConfig.MasqueradeAll, *c.ProxyConfig.IPTablesMasqueradeBit)

 		if err != nil {

 			// This should be fatal, but that would break the integration tests

 			glog.Warningf("WARNING: Could not initialize Kubernetes Proxy. You must run this process as root to use the service proxy: %v", err)

@@ -226,7 +230,7 @@ func (c *NodeConfig) RunProxy() {

 		glog.V(0).Info("Using userspace Proxier.")

 		loadBalancer := userspace.NewLoadBalancerRR()

 		endpointsHandler = loadBalancer

-		proxierUserspace, err := userspace.NewProxier(loadBalancer, c.ProxyConfig.BindAddress, iptInterface, c.ProxyConfig.PortRange, c.ProxyConfig.IptablesSyncPeriod, c.ProxyConfig.UDPIdleTimeout)

+		proxierUserspace, err := userspace.NewProxier(loadBalancer, bindAddr, iptInterface, *portRange, c.ProxyConfig.IPTablesSyncPeriod.Duration, c.ProxyConfig.UDPIdleTimeout.Duration)

 		if err != nil {

 			// This should be fatal, but that would break the integration tests

 			glog.Warningf("WARNING: Could not initialize Kubernetes Proxy. You must run this process as root to use the service proxy: %v", err)

@@ -237,7 +241,7 @@ func (c *NodeConfig) RunProxy() {

 		glog.V(0).Info("Tearing down pure-iptables proxy rules. Errors here are acceptable.")

 		iptables.CleanupLeftovers(iptInterface)

 	default:

-		glog.Fatalf("Unknown proxy mode %q", c.ProxyConfig.ProxyMode)

+		glog.Fatalf("Unknown proxy mode %q", c.ProxyConfig.Mode)

 	}

 	iptInterface.AddReloadFunc(proxier.Sync)

@@ -262,7 +266,7 @@ func (c *NodeConfig) RunProxy() {

 		endpointsConfig.Channel("api"))

 	recorder.Eventf(c.ProxyConfig.NodeRef, kapi.EventTypeNormal, "Starting", "Starting kube-proxy.")

-	glog.Infof("Started Kubernetes Proxy on %s", c.ProxyConfig.BindAddress.String())

+	glog.Infof("Started Kubernetes Proxy on %s", c.ProxyConfig.BindAddress)

 }

 // TODO: more generic location

@@ -31,6 +31,7 @@ import (

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

 	cmdflags "github.com/openshift/origin/pkg/cmd/util/flags"

 	"github.com/openshift/origin/pkg/cmd/util/variable"

+	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"

 )

 // NodeConfig represents the required parameters to start the OpenShift node

@@ -167,8 +168,8 @@ func BuildKubernetesNodeConfig(options configapi.NodeConfig) (*NodeConfig, error

 	// provide any config overrides

 	cfg.NodeName = options.NodeName

-	cfg.KubeClient = kubeClient

-	cfg.EventClient = eventClient

+	cfg.KubeClient = internalclientset.FromUnversionedClient(kubeClient)

+	cfg.EventClient = internalclientset.FromUnversionedClient(eventClient)

 	cfg.DockerExecHandler = dockerExecHandler

 	// docker-in-docker (dind) deployments are used for testing

@@ -299,14 +300,15 @@ func buildKubeProxyConfig(options configapi.NodeConfig) (*proxyoptions.ProxyServ

 	if ip == nil {

 		return nil, fmt.Errorf("The provided value to bind to must be an ip:port: %q", addr)

 	}

-	proxyconfig.BindAddress = ip

+	proxyconfig.BindAddress = ip.String()

 	// HealthzPort, HealthzBindAddress - disable

 	proxyconfig.HealthzPort = 0

-	proxyconfig.HealthzBindAddress = nil

+	proxyconfig.HealthzBindAddress = ""

 	// OOMScoreAdj, ResourceContainer - clear, we don't run in a container

-	proxyconfig.OOMScoreAdj = 0

+	oomScoreAdj := 0

+	proxyconfig.OOMScoreAdj = &oomScoreAdj

 	proxyconfig.ResourceContainer = ""

 	// use the same client as the node

@@ -317,14 +319,16 @@ func buildKubeProxyConfig(options configapi.NodeConfig) (*proxyoptions.ProxyServ

 	// HostnameOverride, use default

 	// ProxyMode, set to iptables

-	proxyconfig.ProxyMode = "iptables"

+	proxyconfig.Mode = "iptables"

 	// IptablesSyncPeriod, set to our config value

 	syncPeriod, err := time.ParseDuration(options.IPTablesSyncPeriod)

 	if err != nil {

 		return nil, fmt.Errorf("Cannot parse the provided ip-tables sync period (%s) : %v", options.IPTablesSyncPeriod, err)

 	}

-	proxyconfig.IptablesSyncPeriod = syncPeriod

+	proxyconfig.IPTablesSyncPeriod = unversioned.Duration{

+		Duration: syncPeriod,

+	}

 	// ConfigSyncPeriod, use default

@@ -1,12 +1,13 @@

 package kubernetes

 import (

-	"net"

 	"reflect"

 	"testing"

 	"time"

 	proxyoptions "k8s.io/kubernetes/cmd/kube-proxy/app/options"

+	"k8s.io/kubernetes/pkg/api/unversioned"

+	"k8s.io/kubernetes/pkg/apis/componentconfig"

 	"k8s.io/kubernetes/pkg/kubelet/qos"

 )

@@ -14,19 +15,26 @@ func TestProxyConfig(t *testing.T) {

 	// This is a snapshot of the default config

 	// If the default changes (new fields are added, or default values change), we want to know

 	// Once we've reacted to the changes appropriately in buildKubeProxyConfig(), update this expected default to match the new upstream defaults

+	oomScoreAdj := qos.KubeProxyOOMScoreAdj

+	ipTablesMasqueratebit := 14

 	expectedDefaultConfig := &proxyoptions.ProxyServerConfig{

-		BindAddress:                    net.ParseIP("0.0.0.0"),

-		HealthzPort:                    10249,

-		HealthzBindAddress:             net.ParseIP("127.0.0.1"),

-		OOMScoreAdj:                    qos.KubeProxyOOMScoreAdj,

-		ResourceContainer:              "/kube-proxy",

-		IptablesSyncPeriod:             30 * time.Second,

-		ConfigSyncPeriod:               15 * time.Minute,

-		KubeAPIQPS:                     5.0,

-		KubeAPIBurst:                   10,

-		UDPIdleTimeout:                 250 * time.Millisecond,

-		ConntrackMax:                   256 * 1024, // 4x default (64k)

-		ConntrackTCPTimeoutEstablished: 86400,      // 1 day (1/5 default)

+		KubeProxyConfiguration: componentconfig.KubeProxyConfiguration{

+			BindAddress:        "0.0.0.0",

+			HealthzPort:        10249,

+			HealthzBindAddress: "127.0.0.1",

+			OOMScoreAdj:        &oomScoreAdj,

+			ResourceContainer:  "/kube-proxy",

+			IPTablesSyncPeriod: unversioned.Duration{Duration: 30 * time.Second},

+			// from k8s.io/kubernetes/cmd/kube-proxy/app/options/options.go

+			// defaults to 14.

+			IPTablesMasqueradeBit:          &ipTablesMasqueratebit,

+			UDPIdleTimeout:                 unversioned.Duration{Duration: 250 * time.Millisecond},

+			ConntrackMax:                   256 * 1024,                                          // 4x default (64k)

+			ConntrackTCPEstablishedTimeout: unversioned.Duration{Duration: 86400 * time.Second}, // 1 day (1/5 default)

+		},

+		ConfigSyncPeriod: 15 * time.Minute,

+		KubeAPIQPS:       5.0,

+		KubeAPIBurst:     10,

 	}

 	actualDefaultConfig := proxyoptions.NewProxyConfig()