@@ -65,6 +65,9 @@ os::log::start_system_logger

 function exectest() {

 	echo "Running $1..."

+	export TEST_ETCD_DIR="${TMPDIR:-/tmp}/etcd-${1}"

+	rm -fr "${TEST_ETCD_DIR}"

+	mkdir -p "${TEST_ETCD_DIR}"

 	result=1

 	if [ -n "${DEBUG-}" ]; then

 		dlv exec "${testexec}" -- -test.run="^$1$" "${@:2}"

@@ -82,6 +85,8 @@ function exectest() {

 	if [[ ${result} -eq 0 ]]; then

 		os::text::print_green "ok      $1"

+		# Remove the etcd directory to cleanup the space.

+		rm -rf "${TEST_ETCD_DIR}"

 		exit 0

 	else

 		os::text::print_red "failed  $1"

@@ -2,18 +2,20 @@ package dockerhelper

 import (

 	"bytes"

-	"encoding/json"

 	"errors"

 	"fmt"

 	"io"

 	"net"

 	"net/url"

 	"strconv"

-	"strings"

+	"time"

 	"github.com/blang/semver"

+	dockerclient "github.com/docker/engine-api/client"

+	"github.com/docker/engine-api/types/registry"

 	docker "github.com/fsouza/go-dockerclient"

 	"github.com/golang/glog"

+	"golang.org/x/net/context"

 	starterrors "github.com/openshift/origin/pkg/bootstrap/docker/errors"

 	"github.com/openshift/origin/pkg/util/docker/dockerfile/builder/imageprogress"

@@ -23,13 +25,15 @@ const openShiftInsecureCIDR = "172.30.0.0/16"

 // Helper provides utility functions to help with Docker

 type Helper struct {

-	client *docker.Client

+	client          *docker.Client

+	engineAPIClient *dockerclient.Client

 }

 // NewHelper creates a new Helper

-func NewHelper(client *docker.Client) *Helper {

+func NewHelper(client *docker.Client, engineAPIClient *dockerclient.Client) *Helper {

 	return &Helper{

-		client: client,

+		client:          client,

+		engineAPIClient: engineAPIClient,

 	}

 }

@@ -37,29 +41,11 @@ type RegistryConfig struct {

 	InsecureRegistryCIDRs []string

 }

-func getRegistryConfig(env *docker.Env) (*RegistryConfig, error) {

-	for _, entry := range *env {

-		if !strings.HasPrefix(entry, "RegistryConfig=") {

-			continue

-		}

-		glog.V(5).Infof("Found RegistryConfig entry: %s", entry)

-		value := strings.TrimPrefix(entry, "RegistryConfig=")

-		config := &RegistryConfig{}

-		err := json.Unmarshal([]byte(value), config)

-		if err != nil {

-			glog.V(2).Infof("Error unmarshalling RegistryConfig: %v", err)

-			return nil, err

-		}

-		glog.V(5).Infof("Unmarshalled registry config to %#v", config)

-		return config, nil

-	}

-	return nil, nil

-}

-

-func hasCIDR(cidr string, listOfCIDRs []string) bool {

+func hasCIDR(cidr string, listOfCIDRs []*registry.NetIPNet) bool {

 	glog.V(5).Infof("Looking for %q in %#v", cidr, listOfCIDRs)

 	for _, candidate := range listOfCIDRs {

-		if candidate == cidr {

+		candidateStr := (*net.IPNet)(candidate).String()

+		if candidateStr == cidr {

 			glog.V(5).Infof("Found %q", cidr)

 			return true

 		}

@@ -72,13 +58,18 @@ func hasCIDR(cidr string, listOfCIDRs []string) bool {

 // the appropriate insecure registry argument

 func (h *Helper) HasInsecureRegistryArg() (bool, error) {

 	glog.V(5).Infof("Retrieving Docker daemon info")

-	env, err := h.client.Info()

+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

+	if h.engineAPIClient == nil {

+		return false, fmt.Errorf("the Docker engine API client is not initialized")

+	}

+	info, err := h.engineAPIClient.Info(ctx)

+	defer cancel()

 	if err != nil {

 		glog.V(2).Infof("Could not retrieve Docker info: %v", err)

 		return false, err

 	}

-	glog.V(5).Infof("Docker daemon info: %#v", env)

-	registryConfig, err := getRegistryConfig(env)

+	glog.V(5).Infof("Docker daemon info: %#v", info)

+	registryConfig := info.RegistryConfig

 	if err != nil {

 		return false, err

 	}

@@ -3,15 +3,19 @@ package dockermachine

 import (

 	"bufio"

 	"bytes"

+	"net/http"

 	"os/exec"

 	"path/filepath"

 	"runtime"

 	"strconv"

 	"strings"

+	dockerclient "github.com/docker/engine-api/client"

+	"github.com/docker/go-connections/tlsconfig"

 	docker "github.com/fsouza/go-dockerclient"

 	"github.com/openshift/origin/pkg/bootstrap/docker/errors"

 	"github.com/openshift/origin/pkg/bootstrap/docker/localcmd"

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

 )

 const (

@@ -105,10 +109,10 @@ func Start(name string) error {

 }

 // Client returns a Docker client for the given Docker machine

-func Client(name string) (*docker.Client, error) {

+func Client(name string) (*docker.Client, *dockerclient.Client, error) {

 	output, _, err := localcmd.New(dockerMachineBinary()).Args("env", name).Output()

 	if err != nil {

-		return nil, ErrDockerMachineExec("env", err)

+		return nil, nil, ErrDockerMachineExec("env", err)

 	}

 	scanner := bufio.NewScanner(bytes.NewBufferString(output))

 	var (

@@ -138,7 +142,7 @@ func Client(name string) (*docker.Client, error) {

 		}

 	}

 	var client *docker.Client

-	if tlsVerify {

+	if len(certPath) > 0 {

 		cert := filepath.Join(certPath, "cert.pem")

 		key := filepath.Join(certPath, "key.pem")

 		ca := filepath.Join(certPath, "ca.pem")

@@ -147,10 +151,35 @@ func Client(name string) (*docker.Client, error) {

 		client, err = docker.NewVersionedClient(dockerHost, "")

 	}

 	if err != nil {

-		return nil, errors.NewError("could not get Docker client for machine %s", name).WithCause(err)

+		return nil, nil, errors.NewError("could not get Docker client for machine %s", name).WithCause(err)

 	}

 	client.SkipServerVersionCheck = true

-	return client, nil

+

+	var httpClient *http.Client

+	if len(certPath) > 0 {

+		tlscOptions := tlsconfig.Options{

+			CAFile:             filepath.Join(certPath, "ca.pem"),

+			CertFile:           filepath.Join(certPath, "cert.pem"),

+			KeyFile:            filepath.Join(certPath, "key.pem"),

+			InsecureSkipVerify: !tlsVerify,

+		}

+		tlsc, tlsErr := tlsconfig.Client(tlscOptions)

+		if tlsErr != nil {

+			return nil, nil, errors.NewError("could not create TLS config client for machine %s", name).WithCause(tlsErr)

+		}

+		httpClient = &http.Client{

+			Transport: net.SetTransportDefaults(&http.Transport{

+				TLSClientConfig: tlsc,

+			}),

+		}

+	}

+

+	engineAPIClient, err := dockerclient.NewClient(dockerHost, "", httpClient, nil)

+	if err != nil {

+		return nil, nil, errors.NewError("cannot create Docker engine API client").WithCause(err)

+	}

+

+	return client, engineAPIClient, nil

 }

 // IsAvailable returns true if the docker-machine executable can be found in the PATH

@@ -63,7 +63,7 @@ func (c *ClientStopConfig) Stop(out io.Writer) error {

 	if err != nil {

 		return err

 	}

-	helper := dockerhelper.NewHelper(client)

+	helper := dockerhelper.NewHelper(client, nil)

 	glog.V(4).Infof("Stopping and removing origin container")

 	if err = helper.StopAndRemoveContainer("origin"); err != nil {

 		glog.V(1).Infof("Error stopping origin container: %v", err)

@@ -92,7 +92,8 @@ func (c *ClientStopConfig) Stop(out io.Writer) error {

 func (c *ClientStopConfig) getDockerClient(out io.Writer) (*docker.Client, error) {

 	// Get Docker client

 	if len(c.DockerMachine) > 0 {

-		return getDockerMachineClient(c.DockerMachine, out)

+		client, _, err := getDockerMachineClient(c.DockerMachine, out)

+		return client, err

 	}

 	client, _, err := dockerutil.NewHelper().GetClient()

 	if err != nil {

@@ -74,7 +74,7 @@ type StartOptions struct {

 // NewHelper creates a new OpenShift helper

 func NewHelper(client *docker.Client, hostHelper *host.HostHelper, image, containerName, publicHostname, routingSuffix string) *Helper {

 	return &Helper{

-		dockerHelper:  dockerhelper.NewHelper(client),

+		dockerHelper:  dockerhelper.NewHelper(client, nil),

 		execHelper:    exec.NewExecHelper(client, containerName),

 		hostHelper:    hostHelper,

 		runHelper:     run.NewRunHelper(client),

@@ -6,8 +6,10 @@ import (

 	"net"

 	"os"

 	"path/filepath"

+	"runtime"

 	"github.com/blang/semver"

+	dockerclient "github.com/docker/engine-api/client"

 	docker "github.com/fsouza/go-dockerclient"

 	"github.com/golang/glog"

 	"github.com/spf13/cobra"

@@ -168,6 +170,7 @@ type ClientStartConfig struct {

 	ServerLogLevel    int

 	dockerClient    *docker.Client

+	engineAPIClient *dockerclient.Client

 	dockerHelper    *dockerhelper.Helper

 	hostHelper      *host.HostHelper

 	openShiftHelper *openshift.Helper

@@ -307,7 +310,7 @@ func (c *ClientStartConfig) GetDockerClient(out io.Writer) error {

 	if len(c.DockerMachine) > 0 {

 		glog.V(2).Infof("Getting client for Docker machine %q", c.DockerMachine)

-		c.dockerClient, err = getDockerMachineClient(c.DockerMachine, out)

+		c.dockerClient, c.engineAPIClient, err = getDockerMachineClient(c.DockerMachine, out)

 		if err != nil {

 			return errors.ErrNoDockerMachineClient(c.DockerMachine, err)

 		}

@@ -337,7 +340,18 @@ func (c *ClientStartConfig) GetDockerClient(out io.Writer) error {

 	if err != nil {

 		return errors.ErrNoDockerClient(err)

 	}

-

+	// FIXME: Workaround for docker engine API client on OS X - sets the default to

+	// the wrong DOCKER_HOST string

+	if runtime.GOOS == "darwin" {

+		dockerHost := os.Getenv("DOCKER_HOST")

+		if len(dockerHost) == 0 {

+			os.Setenv("DOCKER_HOST", "unix:///var/run/docker.sock")

+		}

+	}

+	c.engineAPIClient, err = dockerclient.NewEnvClient()

+	if err != nil {

+		return errors.ErrNoDockerClient(err)

+	}

 	if err = c.dockerClient.Ping(); err != nil {

 		return errors.ErrCannotPingDocker(err)

 	}

@@ -615,7 +629,7 @@ func (c *ClientStartConfig) HostHelper() *host.HostHelper {

 // DockerHelper returns a helper object to work with the Docker client

 func (c *ClientStartConfig) DockerHelper() *dockerhelper.Helper {

 	if c.dockerHelper == nil {

-		c.dockerHelper = dockerhelper.NewHelper(c.dockerClient)

+		c.dockerHelper = dockerhelper.NewHelper(c.dockerClient, c.engineAPIClient)

 	}

 	return c.dockerHelper

 }

@@ -639,12 +653,12 @@ func (c *ClientStartConfig) openShiftImage() string {

 	return fmt.Sprintf("%s:%s", c.Image, c.ImageVersion)

 }

-func getDockerMachineClient(machine string, out io.Writer) (*docker.Client, error) {

+func getDockerMachineClient(machine string, out io.Writer) (*docker.Client, *dockerclient.Client, error) {

 	if !dockermachine.IsRunning(machine) {

 		fmt.Fprintf(out, "Starting Docker machine '%s'\n", machine)

 		err := dockermachine.Start(machine)

 		if err != nil {

-			return nil, errors.NewError("cannot start Docker machine %q", machine).WithCause(err)

+			return nil, nil, errors.NewError("cannot start Docker machine %q", machine).WithCause(err)

 		}

 		fmt.Fprintf(out, "Started Docker machine '%s'\n", machine)

 	}

@@ -94,7 +94,7 @@ func TestDefaults(t *testing.T) {

 			Ok: func(out runtime.Object) bool {

 				obj := out.(*api.BuildConfig)

 				// conversion drops this trigger because it has no type

-				return len(obj.Spec.Triggers) == 0

+				return (len(obj.Spec.Triggers) == 0) && (obj.Spec.RunPolicy == api.BuildRunPolicySerial)

 			},

 		},

 	}

@@ -81,7 +81,12 @@ func (h *Helper) GetDockerAuth(imageName, authType string) (docker.AuthConfigura

 		return docker.AuthConfiguration{}, false

 	}

 	glog.V(3).Infof("Using %s user for Docker authentication for image %s", authConfs[0].Username, imageName)

-	return authConfs[0], true

+	return docker.AuthConfiguration{

+		Username:      authConfs[0].Username,

+		Password:      authConfs[0].Password,

+		Email:         authConfs[0].Email,

+		ServerAddress: authConfs[0].ServerAddress,

+	}, true

 }

 // GetDockercfgFile returns the path to the dockercfg file

@@ -302,6 +302,9 @@ func SetOpenShiftDefaults(config *restclient.Config) error {

 	// if err != nil {

 	// 	return fmt.Errorf("API group %q is not recognized (valid values: %v)", config.GroupVersion.Group, latest.Versions)

 	// }

+	if config.NegotiatedSerializer == nil {

+		config.NegotiatedSerializer = kapi.Codecs

+	}

 	if config.Codec == nil {

 		config.Codec = kapi.Codecs.LegacyCodec(*config.GroupVersion)

@@ -137,7 +137,7 @@ func NewCommandCLI(name, fullName string, in io.Reader, out, errout io.Writer) *

 				cmd.NewCmdLogs(cmd.LogsRecommendedName, fullName, f, out),

 				cmd.NewCmdRsh(cmd.RshRecommendedName, fullName, f, in, out, errout),

 				rsync.NewCmdRsync(rsync.RsyncRecommendedName, fullName, f, out, errout),

-				cmd.NewCmdPortForward(fullName, f),

+				cmd.NewCmdPortForward(fullName, f, out, errout),

 				cmd.NewCmdDebug(fullName, f, in, out, errout),

 				cmd.NewCmdExec(fullName, f, in, out, errout),

 				cmd.NewCmdProxy(fullName, f, out),

@@ -1,6 +1,8 @@

 package rsync

 import (

+	"io"

+

 	"k8s.io/kubernetes/pkg/client/restclient"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

 	"k8s.io/kubernetes/pkg/client/unversioned/portforward"

@@ -15,6 +17,8 @@ type portForwarder struct {

 	PodName   string

 	Client    *kclient.Client

 	Config    *restclient.Config

+	Out       io.Writer

+	ErrOut    io.Writer

 }

 // ensure that portForwarder implements the forwarder interface

@@ -33,7 +37,8 @@ func (f *portForwarder) ForwardPorts(ports []string, stopChan <-chan struct{}) e

 	if err != nil {

 		return err

 	}

-	fw, err := portforward.New(dialer, ports, stopChan)

+	// TODO: Make os.Stdout/Stderr configurable

+	fw, err := portforward.New(dialer, ports, stopChan, f.Out, f.ErrOut)

 	if err != nil {

 		return err

 	}

@@ -64,5 +69,7 @@ func newPortForwarder(f *clientcmd.Factory, o *RsyncOptions) (forwarder, error)

 		PodName:   o.PodName(),

 		Client:    client,

 		Config:    config,

+		Out:       o.Out,

+		ErrOut:    o.ErrOut,

 	}, nil

 }

@@ -213,8 +213,8 @@ const (

 )

 // NewCmdPortForward is a wrapper for the Kubernetes cli port-forward command

-func NewCmdPortForward(fullName string, f *clientcmd.Factory) *cobra.Command {

-	cmd := kcmd.NewCmdPortForward(f.Factory)

+func NewCmdPortForward(fullName string, f *clientcmd.Factory, out, errout io.Writer) *cobra.Command {

+	cmd := kcmd.NewCmdPortForward(f.Factory, out, errout)

 	cmd.Long = portForwardLong

 	cmd.Example = fmt.Sprintf(portForwardExample, fullName)

 	return cmd

@@ -43,6 +43,8 @@ var (

 	APIGroupExtensions  = "extensions"

 	APIGroupAutoscaling = "autoscaling"

 	APIGroupBatch       = "batch"

+	APIGroupPolicy      = "policy"

+	APIGroupApps        = "apps"

 	// Map of group names to allowed REST API versions

 	KubeAPIGroupsToAllowedVersions = map[string][]string{

@@ -50,6 +52,7 @@ var (

 		APIGroupExtensions:  {"v1beta1"},

 		APIGroupAutoscaling: {"v1"},

 		APIGroupBatch:       {"v1"},

+		APIGroupApps:        {"v1alpha1"},

 	}

 	// Map of group names to known, but disallowed REST API versions

 	KubeAPIGroupsToDeadVersions = map[string][]string{

@@ -57,6 +60,8 @@ var (

 		APIGroupExtensions:  {},

 		APIGroupAutoscaling: {},

 		APIGroupBatch:       {},

+		APIGroupPolicy:      {},

+		APIGroupApps:        {},

 	}

 	KnownKubeAPIGroups = sets.StringKeySet(KubeAPIGroupsToAllowedVersions)

@@ -10,7 +10,7 @@ import (

 )

 func TestKnownAPIGroups(t *testing.T) {

-	unexposedGroups := sets.NewString("authorization.k8s.io", "componentconfig", "metrics")

+	unexposedGroups := sets.NewString("authorization.k8s.io", "componentconfig", "metrics", "policy")

 	enabledGroups := sets.NewString()

 	for _, enabledVersion := range registered.EnabledVersions() {

@@ -14,7 +14,7 @@ import (

 	"github.com/golang/glog"

 	"github.com/coreos/etcd/etcdserver"

-	"github.com/coreos/etcd/etcdserver/etcdhttp"

+	etcdhttp "github.com/coreos/etcd/etcdserver/api/v2http"

 	"github.com/coreos/etcd/pkg/osutil"

 	"github.com/coreos/etcd/pkg/transport"

 	"github.com/coreos/etcd/pkg/types"

@@ -61,7 +61,11 @@ func startEtcd(cfg *config) (<-chan struct{}, error) {

 	plns := make([]net.Listener, 0)

 	for _, u := range cfg.lpurls {

 		var l net.Listener

-		l, err = transport.NewTimeoutListener(u.Host, u.Scheme, cfg.peerTLSInfo, rafthttp.ConnReadTimeout, rafthttp.ConnWriteTimeout)

+		peerTLSConfig, err := cfg.peerTLSInfo.ServerConfig()

+		if err != nil {

+			return nil, err

+		}

+		l, err = transport.NewTimeoutListener(u.Host, u.Scheme, peerTLSConfig, rafthttp.ConnReadTimeout, rafthttp.ConnWriteTimeout)

 		if err != nil {

 			return nil, err

 		}

@@ -86,7 +90,11 @@ func startEtcd(cfg *config) (<-chan struct{}, error) {

 		if err != nil {

 			return nil, err

 		}

-		l, err = transport.NewKeepAliveListener(l, u.Scheme, cfg.clientTLSInfo)

+		clientTLSConfig, err := cfg.clientTLSInfo.ServerConfig()

+		if err != nil {

+			return nil, err

+		}

+		l, err = transport.NewKeepAliveListener(l, u.Scheme, clientTLSConfig)

 		if err != nil {

 			return nil, err

 		}

@@ -13,6 +13,9 @@ import (

 	kapi "k8s.io/kubernetes/pkg/api"

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

 	"k8s.io/kubernetes/pkg/api/v1"

+	appsv1alpha1 "k8s.io/kubernetes/pkg/apis/apps/v1alpha1"

+	autoscalingv1 "k8s.io/kubernetes/pkg/apis/autoscaling/v1"

+	batchv1 "k8s.io/kubernetes/pkg/apis/batch/v1"

 	extv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"

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

 	"k8s.io/kubernetes/pkg/client/record"

@@ -56,10 +59,8 @@ import (

 )

 const (

-	KubeAPIPrefix                  = "/api"

-	KubeAPIPrefixV1                = KubeAPIPrefix + "/v1"

-	KubeAPIGroupPrefix             = "/apis"

-	KubeAPIExtensionsPrefixV1beta1 = KubeAPIGroupPrefix + "/extensions/v1beta1"

+	KubeAPIPrefix      = "/api"

+	KubeAPIGroupPrefix = "/apis"

 )

 // InstallAPI starts a Kubernetes master and registers the supported REST APIs

@@ -74,12 +75,21 @@ func (c *MasterConfig) InstallAPI(container *restful.Container) ([]string, error

 	}

 	messages := []string{}

+	// v1 has to be printed separately since it's served from different endpoint than groups

 	if configapi.HasKubernetesAPIVersion(c.Options, v1.SchemeGroupVersion) {

-		messages = append(messages, fmt.Sprintf("Started Kubernetes API at %%s%s", KubeAPIPrefixV1))

+		messages = append(messages, fmt.Sprintf("Started Kubernetes API at %%s%s", KubeAPIPrefix))

 	}

-	if configapi.HasKubernetesAPIVersion(c.Options, extv1beta1.SchemeGroupVersion) {

-		messages = append(messages, fmt.Sprintf("Started Kubernetes API Extensions at %%s%s", KubeAPIExtensionsPrefixV1beta1))

+	versions := []unversioned.GroupVersion{

+		extv1beta1.SchemeGroupVersion,

+		batchv1.SchemeGroupVersion,

+		autoscalingv1.SchemeGroupVersion,

+		appsv1alpha1.SchemeGroupVersion,

+	}

+	for _, ver := range versions {

+		if configapi.HasKubernetesAPIVersion(c.Options, ver) {

+			messages = append(messages, fmt.Sprintf("Started Kubernetes API %s at %%s%s", ver.String(), KubeAPIGroupPrefix))

+		}

 	}

 	return messages, nil

@@ -93,7 +103,7 @@ func (c *MasterConfig) RunNamespaceController(kubeClient internalclientset.Inter

 		glog.Fatalf("Failed to get supported resources from server: %v", err)

 	}

 	namespaceController := namespacecontroller.NewNamespaceController(kubeClient, clientPool, groupVersionResources, c.ControllerManager.NamespaceSyncPeriod.Duration, kapi.FinalizerKubernetes)

-	go namespaceController.Run(c.ControllerManager.ConcurrentNamespaceSyncs, utilwait.NeverStop)

+	go namespaceController.Run(int(c.ControllerManager.ConcurrentNamespaceSyncs), utilwait.NeverStop)

 }

 // RunPersistentVolumeClaimBinder starts the Kubernetes Persistent Volume Claim Binder

@@ -143,8 +153,8 @@ func (c *MasterConfig) RunPersistentVolumeClaimRecycler(recyclerImageName string

 	volumeConfig := c.ControllerManager.VolumeConfiguration

 	hostPathConfig := volume.VolumeConfig{

-		RecyclerMinimumTimeout:   volumeConfig.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath,

-		RecyclerTimeoutIncrement: volumeConfig.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath,

+		RecyclerMinimumTimeout:   int(volumeConfig.PersistentVolumeRecyclerConfiguration.MinimumTimeoutHostPath),

+		RecyclerTimeoutIncrement: int(volumeConfig.PersistentVolumeRecyclerConfiguration.IncrementTimeoutHostPath),

 		RecyclerPodTemplate:      defaultScrubPod,

 	}

@@ -154,8 +164,8 @@ func (c *MasterConfig) RunPersistentVolumeClaimRecycler(recyclerImageName string

 		}

 	}

 	nfsConfig := volume.VolumeConfig{

-		RecyclerMinimumTimeout:   volumeConfig.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS,

-		RecyclerTimeoutIncrement: volumeConfig.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS,

+		RecyclerMinimumTimeout:   int(volumeConfig.PersistentVolumeRecyclerConfiguration.MinimumTimeoutNFS),

+		RecyclerTimeoutIncrement: int(volumeConfig.PersistentVolumeRecyclerConfiguration.IncrementTimeoutNFS),

 		RecyclerPodTemplate:      defaultScrubPod,

 	}

@@ -177,7 +187,7 @@ func (c *MasterConfig) RunPersistentVolumeClaimRecycler(recyclerImageName string

 	recycler, err := volumeclaimbinder.NewPersistentVolumeRecycler(

 		clientadapter.FromUnversionedClient(client),

 		c.ControllerManager.PVClaimBinderSyncPeriod.Duration,

-		volumeConfig.PersistentVolumeRecyclerConfiguration.MaximumRetry,

+		int(volumeConfig.PersistentVolumeRecyclerConfiguration.MaximumRetry),

 		allPlugins,

 		c.CloudProvider,

 	)

@@ -208,19 +218,19 @@ func attemptToLoadRecycler(path string, config *volume.VolumeConfig) error {

 // RunReplicationController starts the Kubernetes replication controller sync loop

 func (c *MasterConfig) RunReplicationController(client *client.Client) {

-	controllerManager := replicationcontroller.NewReplicationManager(

+	controllerManager := replicationcontroller.NewReplicationManagerFromClient(

 		clientadapter.FromUnversionedClient(client),

 		kctrlmgr.ResyncPeriod(c.ControllerManager),

 		replicationcontroller.BurstReplicas,

-		c.ControllerManager.LookupCacheSizeForRC,

+		int(c.ControllerManager.LookupCacheSizeForRC),

 	)

-	go controllerManager.Run(c.ControllerManager.ConcurrentRCSyncs, utilwait.NeverStop)

+	go controllerManager.Run(int(c.ControllerManager.ConcurrentRCSyncs), utilwait.NeverStop)

 }

 // RunJobController starts the Kubernetes job controller sync loop

 func (c *MasterConfig) RunJobController(client *client.Client) {

-	controller := jobcontroller.NewJobController(clientadapter.FromUnversionedClient(client), kctrlmgr.ResyncPeriod(c.ControllerManager))

-	go controller.Run(c.ControllerManager.ConcurrentJobSyncs, utilwait.NeverStop)

+	controller := jobcontroller.NewJobControllerFromClient(clientadapter.FromUnversionedClient(client), kctrlmgr.ResyncPeriod(c.ControllerManager))

+	go controller.Run(int(c.ControllerManager.ConcurrentJobSyncs), utilwait.NeverStop)

 }

 // RunHPAController starts the Kubernetes hpa controller sync loop

@@ -238,18 +248,18 @@ func (c *MasterConfig) RunHPAController(oc *osclient.Client, kc *client.Client,

 }

 func (c *MasterConfig) RunDaemonSetsController(client *client.Client) {

-	controller := daemon.NewDaemonSetsController(

+	controller := daemon.NewDaemonSetsControllerFromClient(

 		clientadapter.FromUnversionedClient(client),

 		kctrlmgr.ResyncPeriod(c.ControllerManager),

-		c.ControllerManager.LookupCacheSizeForDaemonSet,

+		int(c.ControllerManager.LookupCacheSizeForDaemonSet),

 	)

-	go controller.Run(c.ControllerManager.ConcurrentDaemonSetSyncs, utilwait.NeverStop)

+	go controller.Run(int(c.ControllerManager.ConcurrentDaemonSetSyncs), utilwait.NeverStop)

 }

 // RunEndpointController starts the Kubernetes replication controller sync loop

 func (c *MasterConfig) RunEndpointController() {

-	endpoints := endpointcontroller.NewEndpointController(clientadapter.FromUnversionedClient(c.KubeClient), kctrlmgr.ResyncPeriod(c.ControllerManager))

-	go endpoints.Run(c.ControllerManager.ConcurrentEndpointSyncs, utilwait.NeverStop)

+	endpoints := endpointcontroller.NewEndpointControllerFromClient(clientadapter.FromUnversionedClient(c.KubeClient), kctrlmgr.ResyncPeriod(c.ControllerManager))

+	go endpoints.Run(int(c.ControllerManager.ConcurrentEndpointSyncs), utilwait.NeverStop)

 }

@@ -284,15 +294,15 @@ func (c *MasterConfig) RunResourceQuotaManager() {

 		ResyncPeriod:              controller.StaticResyncPeriodFunc(c.ControllerManager.ResourceQuotaSyncPeriod.Duration),

 		Registry:                  resourceQuotaRegistry,

 		GroupKindsToReplenish:     groupKindsToReplenish,

-		ControllerFactory:         kresourcequota.NewReplenishmentControllerFactory(client),

+		ControllerFactory:         kresourcequota.NewReplenishmentControllerFactoryFromClient(client),

 		ReplenishmentResyncPeriod: kctrlmgr.ResyncPeriod(c.ControllerManager),

 	}

-	go kresourcequota.NewResourceQuotaController(resourceQuotaControllerOptions).Run(c.ControllerManager.ConcurrentResourceQuotaSyncs, utilwait.NeverStop)

+	go kresourcequota.NewResourceQuotaController(resourceQuotaControllerOptions).Run(int(c.ControllerManager.ConcurrentResourceQuotaSyncs), utilwait.NeverStop)

 }

 func (c *MasterConfig) RunGCController(client *client.Client) {

 	if c.ControllerManager.TerminatedPodGCThreshold > 0 {

-		gcController := gccontroller.New(clientadapter.FromUnversionedClient(client), kctrlmgr.ResyncPeriod(c.ControllerManager), c.ControllerManager.TerminatedPodGCThreshold)

+		gcController := gccontroller.New(clientadapter.FromUnversionedClient(client), kctrlmgr.ResyncPeriod(c.ControllerManager), int(c.ControllerManager.TerminatedPodGCThreshold))

 		go gcController.Run(utilwait.NeverStop)

 	}

 }

@@ -309,8 +319,8 @@ func (c *MasterConfig) RunNodeController() {

 		clientadapter.FromUnversionedClient(c.KubeClient),

 		s.PodEvictionTimeout.Duration,

-		flowcontrol.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst),

-		flowcontrol.NewTokenBucketRateLimiter(s.DeletingPodsQps, s.DeletingPodsBurst), // upstream uses the same ones too

+		flowcontrol.NewTokenBucketRateLimiter(s.DeletingPodsQps, int(s.DeletingPodsBurst)),

+		flowcontrol.NewTokenBucketRateLimiter(s.DeletingPodsQps, int(s.DeletingPodsBurst)), // upstream uses the same ones too

 		s.NodeMonitorGracePeriod.Duration,

 		s.NodeStartupGracePeriod.Duration,

@@ -340,7 +350,7 @@ func (c *MasterConfig) createSchedulerConfig() (*scheduler.Config, error) {

 	var configData []byte

 	// TODO make the rate limiter configurable

-	configFactory := factory.NewConfigFactory(c.KubeClient, kapi.DefaultSchedulerName)

+	configFactory := factory.NewConfigFactory(c.KubeClient, kapi.DefaultSchedulerName, kapi.DefaultHardPodAffinitySymmetricWeight, kapi.DefaultFailureDomains)

 	if _, err := os.Stat(c.Options.SchedulerConfigFile); err == nil {

 		configData, err = ioutil.ReadFile(c.Options.SchedulerConfigFile)

 		if err != nil {

@@ -18,6 +18,8 @@ import (

 	"k8s.io/kubernetes/pkg/admission"

 	kapi "k8s.io/kubernetes/pkg/api"

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

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

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

 	"k8s.io/kubernetes/pkg/apis/extensions"

 	"k8s.io/kubernetes/pkg/apiserver"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

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

 	"k8s.io/kubernetes/pkg/registry/cachesize"

 	"k8s.io/kubernetes/pkg/storage"

 	etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"

+	"k8s.io/kubernetes/pkg/storage/storagebackend"

 	kerrors "k8s.io/kubernetes/pkg/util/errors"

 	"k8s.io/kubernetes/pkg/util/intstr"

 	knet "k8s.io/kubernetes/pkg/util/net"

@@ -39,7 +42,6 @@ import (

 	"github.com/openshift/origin/pkg/cmd/flagtypes"

 	oadmission "github.com/openshift/origin/pkg/cmd/server/admission"

 	configapi "github.com/openshift/origin/pkg/cmd/server/api"

-	"github.com/openshift/origin/pkg/cmd/server/etcd"

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

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

 	overrideapi "github.com/openshift/origin/pkg/quota/admission/clusterresourceoverride/api"

@@ -47,7 +49,23 @@ import (

 )

 // AdmissionPlugins is the full list of admission control plugins to enable in the order they must run

-var AdmissionPlugins = []string{"RunOnceDuration", lifecycle.PluginName, "PodNodeConstraints", "OriginPodNodeEnvironment", overrideapi.PluginName, serviceadmit.ExternalIPPluginName, "LimitRanger", "ServiceAccount", "SecurityContextConstraint", "BuildDefaults", "BuildOverrides", "AlwaysPullImages", "ResourceQuota", "SCCExecRestrictions"}

+var AdmissionPlugins = []string{

+	"RunOnceDuration",

+	lifecycle.PluginName,

+	"PodNodeConstraints",

+	"OriginPodNodeEnvironment",

+	overrideapi.PluginName,

+	serviceadmit.ExternalIPPluginName,

+	"LimitRanger",

+	"ServiceAccount",

+	"SecurityContextConstraint",

+	"BuildDefaults",

+	"BuildOverrides",

+	"AlwaysPullImages",

+	"LimitPodHardAntiAffinityTopology",

+	"ResourceQuota",

+	"SCCExecRestrictions",

+}

 // MasterConfig defines the required values to start a Kubernetes master

 type MasterConfig struct {

@@ -64,12 +82,6 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 		return nil, errors.New("insufficient information to build KubernetesMasterConfig")

 	}

-	// Connect and setup etcd interfaces

-	etcdClient, err := etcd.MakeNewEtcdClient(options.EtcdClientInfo)

-	if err != nil {

-		return nil, err

-	}

-

 	kubeletClientConfig := configapi.GetKubeletClientConfig(options)

 	kubeletClient, err := kubeletclient.NewStaticKubeletClient(kubeletClientConfig)

 	if err != nil {

@@ -205,39 +217,43 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 		proxyClientCerts = append(proxyClientCerts, clientCert)

 	}

-	// TODO you have to know every APIGroup you're enabling or upstream will panic.  Its alternative to panicing is Fataling

-	// It needs a refactor to return errors

-	storageDestinations := genericapiserver.NewStorageDestinations()

-	// storageVersions is a map from API group to allowed versions that must be a version exposed by the REST API or it breaks.

-	// We need to fix the upstream to stop using the storage version as a preferred api version.

-	storageVersions := map[string]string{}

-

-	enabledKubeVersions := configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupKube)

-	if len(enabledKubeVersions) > 0 {

-		kubeStorageVersion := unversioned.GroupVersion{Group: configapi.APIGroupKube, Version: options.EtcdStorageConfig.KubernetesStorageVersion}

-		databaseStorage, err := NewEtcdStorage(etcdClient, kubeStorageVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

-		if err != nil {

-			return nil, fmt.Errorf("Error setting up Kubernetes server storage: %v", err)

-		}

-		storageDestinations.AddAPIGroup(configapi.APIGroupKube, databaseStorage)

-		storageVersions[configapi.APIGroupKube] = options.EtcdStorageConfig.KubernetesStorageVersion

-	}

-

-	// enable this if extensions API is enabled (or batch or autoscaling, since they persist to extensions/v1beta1 for now)

-	// TODO: replace this with a loop over configured storage versions

-	extensionsEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupExtensions)) > 0

-	batchEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupBatch)) > 0

-	autoscalingEnabled := len(configapi.GetEnabledAPIVersionsForGroup(*options.KubernetesMasterConfig, configapi.APIGroupAutoscaling)) > 0

-	if extensionsEnabled || autoscalingEnabled || batchEnabled {

-		// TODO: replace this with a configured storage version for extensions once configuration exposes this

-		extensionsStorageVersion := unversioned.GroupVersion{Group: extensions.GroupName, Version: "v1beta1"}

-		databaseStorage, err := NewEtcdStorage(etcdClient, extensionsStorageVersion, options.EtcdStorageConfig.KubernetesStoragePrefix)

-		if err != nil {

-			return nil, fmt.Errorf("Error setting up Kubernetes extensions server storage: %v", err)

-		}

-		storageDestinations.AddAPIGroup(configapi.APIGroupExtensions, databaseStorage)

-		storageVersions[configapi.APIGroupExtensions] = extensionsStorageVersion.String()

+	resourceEncodingConfig := genericapiserver.NewDefaultResourceEncodingConfig()

+	resourceEncodingConfig.SetVersionEncoding(

+		kapi.GroupName,

+		unversioned.GroupVersion{Group: kapi.GroupName, Version: options.EtcdStorageConfig.KubernetesStorageVersion},

+		kapi.SchemeGroupVersion,

+	)

+

+	resourceEncodingConfig.SetVersionEncoding(

+		extensions.GroupName,

+		unversioned.GroupVersion{Group: extensions.GroupName, Version: "v1beta1"},

+		extensions.SchemeGroupVersion,

+	)

+

+	resourceEncodingConfig.SetVersionEncoding(

+		batch.GroupName,

+		unversioned.GroupVersion{Group: batch.GroupName, Version: "v1"},

+		batch.SchemeGroupVersion,

+	)

+

+	resourceEncodingConfig.SetVersionEncoding(

+		autoscaling.GroupName,

+		unversioned.GroupVersion{Group: autoscaling.GroupName, Version: "v1"},

+		autoscaling.SchemeGroupVersion,

+	)

+

+	etcdConfig := storagebackend.Config{

+		Prefix:     options.EtcdStorageConfig.KubernetesStoragePrefix,

+		ServerList: options.EtcdClientInfo.URLs,

+		KeyFile:    options.EtcdClientInfo.ClientCert.KeyFile,

+		CertFile:   options.EtcdClientInfo.ClientCert.CertFile,

+		CAFile:     options.EtcdClientInfo.CA,

+		DeserializationCacheSize: genericapiserver.DefaultDeserializationCacheSize,

 	}

+	storageFactory := genericapiserver.NewDefaultStorageFactory(etcdConfig, "", kapi.Codecs, resourceEncodingConfig, master.DefaultAPIResourceConfigSource())

+	// the order here is important, it defines which version will be used for storage

+	storageFactory.AddCohabitatingResources(extensions.Resource("jobs"), batch.Resource("jobs"))

+	storageFactory.AddCohabitatingResources(extensions.Resource("horizontalpodautoscalers"), autoscaling.Resource("horizontalpodautoscalers"))

 	// Preserve previous behavior of using the first non-loopback address

 	// TODO: Deprecate this behavior and just require a valid value to be passed in

@@ -260,8 +276,7 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 			Authorizer:       apiserver.NewAlwaysAllowAuthorizer(),

 			AdmissionControl: admissionController,

-			StorageDestinations: storageDestinations,

-			StorageVersions:     storageVersions,

+			StorageFactory: storageFactory,

 			ServiceClusterIPRange: (*net.IPNet)(&server.ServiceClusterIPRange),

 			ServiceNodePortRange:  server.ServiceNodePortRange,

@@ -320,8 +335,8 @@ func BuildKubernetesMasterConfig(options configapi.MasterConfig, requestContextM

 			kapi.ServicePort{Name: "dns-tcp", Port: 53, Protocol: kapi.ProtocolTCP, TargetPort: intstr.FromInt(dnsPort)},

 		)

 		m.ExtraEndpointPorts = append(m.ExtraEndpointPorts,

-			kapi.EndpointPort{Name: "dns", Port: dnsPort, Protocol: kapi.ProtocolUDP},

-			kapi.EndpointPort{Name: "dns-tcp", Port: dnsPort, Protocol: kapi.ProtocolTCP},

+			kapi.EndpointPort{Name: "dns", Port: int32(dnsPort), Protocol: kapi.ProtocolUDP},

+			kapi.EndpointPort{Name: "dns-tcp", Port: int32(dnsPort), Protocol: kapi.ProtocolTCP},

 		)

 	}

@@ -360,5 +375,6 @@ func getAPIResourceConfig(options configapi.MasterConfig) genericapiserver.APIRe

 // NewEtcdStorage returns a storage interface for the provided storage version.

 func NewEtcdStorage(client newetcdclient.Client, version unversioned.GroupVersion, prefix string) (helper storage.Interface, err error) {

-	return etcdstorage.NewEtcdStorage(client, kapi.Codecs.LegacyCodec(version), prefix, false), nil

+	// TODO: Make the cacheSize(200) configurable

+	return etcdstorage.NewEtcdStorage(client, kapi.Codecs.LegacyCodec(version), prefix, false, 200), nil

 }

@@ -15,7 +15,7 @@ import (

 	extensionsapiv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"

 	"k8s.io/kubernetes/pkg/genericapiserver"

 	kubeletclient "k8s.io/kubernetes/pkg/kubelet/client"

-	etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"

+	"k8s.io/kubernetes/pkg/storage/storagebackend"

 	utilconfig "k8s.io/kubernetes/pkg/util/config"

 	"k8s.io/kubernetes/pkg/util/diff"

@@ -30,32 +30,34 @@ func TestAPIServerDefaults(t *testing.T) {

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

 	expectedDefaults := &apiserveroptions.APIServer{

 		ServerRunOptions: &genericapiserver.ServerRunOptions{

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

-			CertDirectory:        "/var/run/kubernetes",

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

-			InsecurePort:         8080,

-			LongRunningRequestRE: "(/|^)((watch|proxy)(/|$)|(logs?|portforward|exec|attach)/?$)",

-			MaxRequestsInFlight:  400,

-			SecurePort:           6443,

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

+			CertDirectory:          "/var/run/kubernetes",

+			InsecureBindAddress:    net.ParseIP("127.0.0.1"),

+			InsecurePort:           8080,

+			LongRunningRequestRE:   "(/|^)((watch|proxy)(/|$)|(logs?|portforward|exec|attach)/?$)",

+			MaxRequestsInFlight:    400,

+			SecurePort:             6443,

+			APIGroupPrefix:         "/apis",

+			APIPrefix:              "/api",

+			EnableLogsSupport:      true,

+			EnableProfiling:        true,

+			EnableWatchCache:       true,

+			MinRequestTimeout:      1800,

+			RuntimeConfig:          utilconfig.ConfigurationMap{},

+			StorageVersions:        registered.AllPreferredGroupVersions(),

+			MasterCount:            1,

+			DefaultStorageVersions: registered.AllPreferredGroupVersions(),

+			StorageConfig: storagebackend.Config{

+				Prefix: "/registry",

+				DeserializationCacheSize: genericapiserver.DefaultDeserializationCacheSize,

+			},

 		},

-		APIGroupPrefix:          "/apis",

-		APIPrefix:               "/api",

+		DefaultStorageMediaType: "application/json",

 		AdmissionControl:        "AlwaysAdmit",

 		AuthorizationMode:       "AlwaysAllow",

 		DeleteCollectionWorkers: 1,

-		EnableLogsSupport:       true,

-		EnableProfiling:         true,

-		EnableWatchCache:        true,

-		EtcdConfig: etcdstorage.EtcdConfig{

-			Prefix: "/registry",

-		},

-		EventTTL:               1 * time.Hour,

-		MasterCount:            1,

-		MasterServiceNamespace: "default",

-		MinRequestTimeout:      1800,

-		RuntimeConfig:          utilconfig.ConfigurationMap{},