@@ -88,7 +88,7 @@ describe('', function() {

       expect(element(by.cssContainingText("h2.service","frontend")).isPresent()).toBe(true);

       expect(element(by.cssContainingText(".pod-template-image","Build: ruby-sample-build")).isPresent()).toBe(true);

       expect(element(by.cssContainingText(".deployment-trigger","new image for test/origin-ruby-sample:latest")).isPresent()).toBe(true);

-      expect(element.all(by.css(".pod-running")).count()).toEqual(2);

+      expect(element.all(by.css(".pod-running")).count()).toEqual(3);

     });

   }); 

new file mode 100644

Binary files /dev/null and b/cpu.pprof differ

@@ -165,10 +165,10 @@

           "replicaSelector": {

             "name": "frontend"

           },

-          "replicas": 1

+          "replicas": 2

         },

         "strategy": {

-          "type": "Recreate"

+          "type": "Rolling"

         }

       },

       "triggers": [

@@ -158,10 +158,10 @@

           "replicaSelector": {

             "name": "frontend"

           },

-          "replicas": 1

+          "replicas": 2

         },

         "strategy": {

-          "type": "Recreate"

+          "type": "Rolling"

         }

       },

       "triggers": [

@@ -158,42 +158,10 @@

           "replicaSelector": {

             "name": "frontend"

           },

-          "replicas": 1

+          "replicas": 2

         },

         "strategy": {

-          "type": "Recreate",

-          "recreateParams": {

-            "pre": {

-              "failurePolicy": "Abort",

-              "execNewPod": {

-                "containerName": "ruby-helloworld",

-                "command": [

-                  "/bin/true"

-                ],

-                "env": [

-                  {

-                    "name": "CUSTOM_VAR1",

-                    "value": "custom_value1"

-                  }

-                ]

-              }

-            },

-            "post": {

-              "failurePolicy": "Ignore",

-              "execNewPod": {

-                "containerName": "ruby-helloworld",

-                "command": [

-                  "/bin/false"

-                ],

-                "env": [

-                  {

-                    "name": "CUSTOM_VAR2",

-                    "value": "custom_value2"

-                  }

-                ]

-              }

-            }

-          }

+          "type": "Rolling"

         }

       },

       "triggers": [

@@ -105,9 +105,26 @@ func fuzzInternalObject(t *testing.T, forVersion string, item runtime.Object, se

 		},

 		func(j *deploy.DeploymentStrategy, c fuzz.Continue) {

 			c.FuzzNoCustom(j)

-			// TODO: we should not have to set defaults, instead we should be able to detect defaults were applied.

-			if len(j.Type) == 0 {

+			mkintp := func(i int) *int64 {

+				v := int64(i)

+				return &v

+			}

+			switch c.Intn(3) {

+			case 0:

+				// TODO: we should not have to set defaults, instead we should be able

+				// to detect defaults were applied.

+				j.Type = deploy.DeploymentStrategyTypeRolling

+				j.RollingParams = &deploy.RollingDeploymentStrategyParams{

+					IntervalSeconds:     mkintp(1),

+					UpdatePeriodSeconds: mkintp(1),

+					TimeoutSeconds:      mkintp(120),

+				}

+			case 1:

 				j.Type = deploy.DeploymentStrategyTypeRecreate

+				j.RollingParams = nil

+			case 2:

+				j.Type = deploy.DeploymentStrategyTypeCustom

+				j.RollingParams = nil

 			}

 		},

 		func(j *deploy.DeploymentCauseImageTrigger, c fuzz.Continue) {

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

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

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

 	deployapi "github.com/openshift/origin/pkg/deploy/api"

-	strategy "github.com/openshift/origin/pkg/deploy/strategy/recreate"

+	"github.com/openshift/origin/pkg/deploy/strategy"

+	"github.com/openshift/origin/pkg/deploy/strategy/recreate"

+	"github.com/openshift/origin/pkg/deploy/strategy/rolling"

 	deployutil "github.com/openshift/origin/pkg/deploy/util"

 	"github.com/openshift/origin/pkg/version"

 )

@@ -78,21 +80,35 @@ func NewCommandDeployer(name string) *cobra.Command {

 // deploy executes a deployment strategy.

 func deploy(kClient kclient.Interface, namespace, deploymentName string) error {

-	newDeployment, oldDeployments, err := getDeployerContext(&realReplicationControllerGetter{kClient}, namespace, deploymentName)

-

+	deployment, oldDeployments, err := getDeployerContext(&realReplicationControllerGetter{kClient}, namespace, deploymentName)

 	if err != nil {

 		return err

 	}

-	// TODO: Choose a strategy based on some input

-	strategy := strategy.NewRecreateDeploymentStrategy(kClient, latest.Codec)

-	return strategy.Deploy(newDeployment, oldDeployments)

+	config, err := deployutil.DecodeDeploymentConfig(deployment, latest.Codec)

+	if err != nil {

+		return fmt.Errorf("couldn't decode DeploymentConfig from deployment %s/%s: %v", deployment.Namespace, deployment.Name, err)

+	}

+

+	var strategy strategy.DeploymentStrategy

+

+	switch config.Template.Strategy.Type {

+	case deployapi.DeploymentStrategyTypeRecreate:

+		strategy = recreate.NewRecreateDeploymentStrategy(kClient, latest.Codec)

+	case deployapi.DeploymentStrategyTypeRolling:

+		recreate := recreate.NewRecreateDeploymentStrategy(kClient, latest.Codec)

+		strategy = rolling.NewRollingDeploymentStrategy(deployment.Namespace, kClient, latest.Codec, recreate)

+	default:

+		return fmt.Errorf("unsupported strategy type: %s", config.Template.Strategy.Type)

+	}

+

+	return strategy.Deploy(deployment, oldDeployments)

 }

 // getDeployerContext finds the target deployment and any deployments it considers to be prior to the

 // target deployment. Only deployments whose LatestVersion is less than the target deployment are

 // considered to be prior.

-func getDeployerContext(controllerGetter replicationControllerGetter, namespace, deploymentName string) (*kapi.ReplicationController, []kapi.ObjectReference, error) {

+func getDeployerContext(controllerGetter replicationControllerGetter, namespace, deploymentName string) (*kapi.ReplicationController, []*kapi.ReplicationController, error) {

 	var err error

 	var newDeployment *kapi.ReplicationController

 	var newConfig *deployapi.DeploymentConfig

@@ -112,14 +128,14 @@ func getDeployerContext(controllerGetter replicationControllerGetter, namespace,

 	// encoded DeploymentConfigs to the new one by LatestVersion. Treat a failure to interpret a given

 	// old deployment as a fatal error to prevent overlapping deployments.

 	var allControllers *kapi.ReplicationControllerList

-	oldDeployments := []kapi.ObjectReference{}

+	oldDeployments := []*kapi.ReplicationController{}

 	if allControllers, err = controllerGetter.List(newDeployment.Namespace, labels.Everything()); err != nil {

 		return nil, nil, fmt.Errorf("Unable to get list replication controllers in deployment namespace %s: %v", newDeployment.Namespace, err)

 	}

 	glog.Infof("Inspecting %d potential prior deployments", len(allControllers.Items))

-	for _, controller := range allControllers.Items {

+	for i, controller := range allControllers.Items {

 		if configName, hasConfigName := controller.Annotations[deployapi.DeploymentConfigAnnotation]; !hasConfigName {

 			glog.Infof("Disregarding replicationController %s (not a deployment)", controller.Name)

 			continue

@@ -135,10 +151,7 @@ func getDeployerContext(controllerGetter replicationControllerGetter, namespace,

 		if oldVersion < newConfig.LatestVersion {

 			glog.Infof("Marking deployment %s as a prior deployment", controller.Name)

-			oldDeployments = append(oldDeployments, kapi.ObjectReference{

-				Namespace: controller.Namespace,

-				Name:      controller.Name,

-			})

+			oldDeployments = append(oldDeployments, &allControllers.Items[i])

 		} else {

 			glog.Infof("Disregarding deployment %s (same as or newer than target)", controller.Name)

 		}

@@ -96,13 +96,13 @@ func TestGetDeploymentContextNoPriorDeployments(t *testing.T) {

 func TestGetDeploymentContextWithPriorDeployments(t *testing.T) {

 	getter := &testReplicationControllerGetter{

 		getFunc: func(namespace, name string) (*kapi.ReplicationController, error) {

-			deployment, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(2), kapi.Codec)

+			deployment, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(3), kapi.Codec)

 			return deployment, nil

 		},

 		listFunc: func(namespace string, selector labels.Selector) (*kapi.ReplicationControllerList, error) {

 			deployment1, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(1), kapi.Codec)

 			deployment2, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(2), kapi.Codec)

-			deployment3, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(3), kapi.Codec)

+			deployment3, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(4), kapi.Codec)

 			deployment4, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(1), kapi.Codec)

 			deployment4.Annotations[deployapi.DeploymentConfigAnnotation] = "another-config"

 			return &kapi.ReplicationControllerList{

@@ -131,8 +131,30 @@ func TestGetDeploymentContextWithPriorDeployments(t *testing.T) {

 		t.Fatal("expected non-nil oldDeployments")

 	}

-	if e, a := 1, len(oldDeployments); e != a {

-		t.Fatalf("expected oldDeployments with size %d, got %d: %#v", e, a, oldDeployments)

+	expected := []string{"config-1", "config-2"}

+	for _, e := range expected {

+		found := false

+		for _, d := range oldDeployments {

+			if d.Name == e {

+				found = true

+				break

+			}

+		}

+		if !found {

+			t.Errorf("expected to find old deployment %s", e)

+		}

+	}

+	for _, d := range oldDeployments {

+		ok := false

+		for _, e := range expected {

+			if d.Name == e {

+				ok = true

+				break

+			}

+		}

+		if !ok {

+			t.Errorf("unexpected old deployment %s", d.Name)

+		}

 	}

 }

@@ -837,10 +837,10 @@ func (c *MasterConfig) RunDeploymentController() error {

 	env = append(env, clientcmd.EnvVarsFromConfig(c.DeployerClientConfig())...)

 	factory := deploycontroller.DeploymentControllerFactory{

-		KubeClient:            kclient,

-		Codec:                 latest.Codec,

-		Environment:           env,

-		RecreateStrategyImage: c.ImageFor("deployer"),

+		KubeClient:    kclient,

+		Codec:         latest.Codec,

+		Environment:   env,

+		DeployerImage: c.ImageFor("deployer"),

 	}

 	controller := factory.Create()

@@ -54,6 +54,8 @@ type DeploymentStrategy struct {

 	CustomParams *CustomDeploymentStrategyParams `json:"customParams,omitempty"`

 	// RecreateParams are the input to the Recreate deployment strategy.

 	RecreateParams *RecreateDeploymentStrategyParams `json:"recreateParams,omitempty"`

+	// RollingParams are the input to the Rolling deployment strategy.

+	RollingParams *RollingDeploymentStrategyParams `json:"rollingParams,omitempty"`

 	// Compute resource requirements to execute the deployment

 	Resources kapi.ResourceRequirements `json:"resources,omitempty"`

 }

@@ -66,6 +68,8 @@ const (

 	DeploymentStrategyTypeRecreate DeploymentStrategyType = "Recreate"

 	// DeploymentStrategyTypeCustom is a user defined strategy.

 	DeploymentStrategyTypeCustom DeploymentStrategyType = "Custom"

+	// DeploymentStrategyTypeRolling uses the Kubernetes RollingUpdater.

+	DeploymentStrategyTypeRolling DeploymentStrategyType = "Rolling"

 )

 // CustomDeploymentStrategyParams are the input to the Custom deployment strategy.

@@ -123,6 +127,20 @@ type ExecNewPodHook struct {

 	ContainerName string `json:"containerName"`

 }

+// RollingDeploymentStrategyParams are the input to the Rolling deployment

+// strategy.

+type RollingDeploymentStrategyParams struct {

+	// UpdatePeriodSeconds is the time to wait between individual pod updates.

+	// If the value is nil, a default will be used.

+	UpdatePeriodSeconds *int64 `json:"updatePeriodSeconds,omitempty" description:"the time to wait between individual pod updates"`

+	// IntervalSeconds is the time to wait between polling deployment status

+	// after update. If the value is nil, a default will be used.

+	IntervalSeconds *int64 `json:"intervalSeconds,omitempty" description:"the time to wait between polling deployment status after update"`

+	// TimeoutSeconds is the time to wait for updates before giving up. If the

+	// value is nil, a default will be used.

+	TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" description:"the time to wait for updates before giving up"`

+}

+

 // DeploymentList is a collection of deployments.

 // DEPRECATED: Like Deployment, this is no longer used.

 type DeploymentList struct {

@@ -19,6 +19,9 @@ func init() {

 			if err := s.Convert(&in.RecreateParams, &out.RecreateParams, 0); err != nil {

 				return err

 			}

+			if err := s.Convert(&in.RollingParams, &out.RollingParams, 0); err != nil {

+				return err

+			}

 			if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil {

 				return err

 			}

@@ -34,6 +37,9 @@ func init() {

 			if err := s.Convert(&in.RecreateParams, &out.RecreateParams, 0); err != nil {

 				return err

 			}

+			if err := s.Convert(&in.RollingParams, &out.RollingParams, 0); err != nil {

+				return err

+			}

 			if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil {

 				return err

 			}

new file mode 100644

@@ -0,0 +1,46 @@

+package v1beta1

+

+import (

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

+)

+

+func init() {

+	mkintp := func(i int) *int64 {

+		v := int64(i)

+		return &v

+	}

+

+	err := api.Scheme.AddDefaultingFuncs(

+		func(obj *deployapi.DeploymentStrategy) {

+			if len(obj.Type) == 0 {

+				obj.Type = deployapi.DeploymentStrategyTypeRolling

+			}

+

+			if obj.Type == deployapi.DeploymentStrategyTypeRolling && obj.RollingParams == nil {

+				obj.RollingParams = &deployapi.RollingDeploymentStrategyParams{

+					IntervalSeconds:     mkintp(1),

+					UpdatePeriodSeconds: mkintp(1),

+					TimeoutSeconds:      mkintp(120),

+				}

+			}

+		},

+		func(obj *deployapi.RollingDeploymentStrategyParams) {

+			if obj.IntervalSeconds == nil {

+				obj.IntervalSeconds = mkintp(1)

+			}

+

+			if obj.UpdatePeriodSeconds == nil {

+				obj.UpdatePeriodSeconds = mkintp(1)

+			}

+

+			if obj.TimeoutSeconds == nil {

+				obj.TimeoutSeconds = mkintp(120)

+			}

+		},

+	)

+	if err != nil {

+		panic(err)

+	}

+}

new file mode 100644

@@ -0,0 +1,53 @@

+package v1beta1_test

+

+import (

+	"reflect"

+	"testing"

+

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

+

+	newer "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+	current "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta1"

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

+)

+

+func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {

+	data, err := current.Codec.Encode(obj)

+	if err != nil {

+		t.Errorf("%v\n %#v", err, obj)

+		return nil

+	}

+	obj2, err := newer.Codec.Decode(data)

+	if err != nil {

+		t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj)

+		return nil

+	}

+	obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object)

+	err = newer.Scheme.Convert(obj2, obj3)

+	if err != nil {

+		t.Errorf("%v\nSource: %#v", err, obj2)

+		return nil

+	}

+	return obj3

+}

+

+func TestDefaults_rollingParams(t *testing.T) {

+	c := &deployapi.DeploymentConfig{

+		Template: deployapi.DeploymentTemplate{},

+	}

+	o := roundTrip(t, runtime.Object(c))

+	config := o.(*deployapi.DeploymentConfig)

+	strat := config.Template.Strategy

+	if e, a := deployapi.DeploymentStrategyTypeRolling, strat.Type; e != a {

+		t.Errorf("expected strategy type %s, got %s", e, a)

+	}

+	if e, a := int64(1), *strat.RollingParams.UpdatePeriodSeconds; e != a {

+		t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a)

+	}

+	if e, a := int64(1), *strat.RollingParams.IntervalSeconds; e != a {

+		t.Errorf("expected IntervalSeconds %d, got %d", e, a)

+	}

+	if e, a := int64(120), *strat.RollingParams.TimeoutSeconds; e != a {

+		t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a)

+	}

+}

@@ -55,6 +55,8 @@ type DeploymentStrategy struct {

 	CustomParams *CustomDeploymentStrategyParams `json:"customParams,omitempty"`

 	// RecreateParams are the input to the Recreate deployment strategy.

 	RecreateParams *RecreateDeploymentStrategyParams `json:"recreateParams,omitempty"`

+	// RollingParams are the input to the Rolling deployment strategy.

+	RollingParams *RollingDeploymentStrategyParams `json:"rollingParams,omitempty"`

 	// Compute resource requirements to execute the deployment

 	Resources kapi.ResourceRequirements `json:"resources,omitempty"`

 }

@@ -67,6 +69,8 @@ const (

 	DeploymentStrategyTypeRecreate DeploymentStrategyType = "Recreate"

 	// DeploymentStrategyTypeCustom is a user defined strategy.

 	DeploymentStrategyTypeCustom DeploymentStrategyType = "Custom"

+	// DeploymentStrategyTypeRolling uses the Kubernetes RollingUpdater.

+	DeploymentStrategyTypeRolling DeploymentStrategyType = "Rolling"

 )

 // CustomParams are the input to the Custom deployment strategy.

@@ -124,6 +128,20 @@ type ExecNewPodHook struct {

 	ContainerName string `json:"containerName"`

 }

+// RollingDeploymentStrategyParams are the input to the Rolling deployment

+// strategy.

+type RollingDeploymentStrategyParams struct {

+	// UpdatePeriodSeconds is the time to wait between individual pod updates.

+	// If the value is nil, a default will be used.

+	UpdatePeriodSeconds *int64 `json:"updatePeriodSeconds,omitempty" description:"the time to wait between individual pod updates"`

+	// IntervalSeconds is the time to wait between polling deployment status

+	// after update. If the value is nil, a default will be used.

+	IntervalSeconds *int64 `json:"intervalSeconds,omitempty" description:"the time to wait between polling deployment status after update"`

+	// TimeoutSeconds is the time to wait for updates before giving up. If the

+	// value is nil, a default will be used.

+	TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" description:"the time to wait for updates before giving up"`

+}

+

 // A DeploymentList is a collection of deployments.

 // DEPRECATED: Like Deployment, this is no longer used.

 type DeploymentList struct {

@@ -93,6 +93,9 @@ func init() {

 			if err := s.Convert(&in.RecreateParams, &out.RecreateParams, 0); err != nil {

 				return err

 			}

+			if err := s.Convert(&in.RollingParams, &out.RollingParams, 0); err != nil {

+				return err

+			}

 			if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil {

 				return err

 			}

@@ -108,6 +111,9 @@ func init() {

 			if err := s.Convert(&in.RecreateParams, &out.RecreateParams, 0); err != nil {

 				return err

 			}

+			if err := s.Convert(&in.RollingParams, &out.RollingParams, 0); err != nil {

+				return err

+			}

 			if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil {

 				return err

 			}

new file mode 100644

@@ -0,0 +1,46 @@

+package v1beta3

+

+import (

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

+)

+

+func init() {

+	mkintp := func(i int) *int64 {

+		v := int64(i)

+		return &v

+	}

+

+	err := api.Scheme.AddDefaultingFuncs(

+		func(obj *deployapi.DeploymentStrategy) {

+			if len(obj.Type) == 0 {

+				obj.Type = deployapi.DeploymentStrategyTypeRolling

+			}

+

+			if obj.Type == deployapi.DeploymentStrategyTypeRolling && obj.RollingParams == nil {

+				obj.RollingParams = &deployapi.RollingDeploymentStrategyParams{

+					IntervalSeconds:     mkintp(1),

+					UpdatePeriodSeconds: mkintp(1),

+					TimeoutSeconds:      mkintp(120),

+				}

+			}

+		},

+		func(obj *deployapi.RollingDeploymentStrategyParams) {

+			if obj.IntervalSeconds == nil {

+				obj.IntervalSeconds = mkintp(1)

+			}

+

+			if obj.UpdatePeriodSeconds == nil {

+				obj.UpdatePeriodSeconds = mkintp(1)

+			}

+

+			if obj.TimeoutSeconds == nil {

+				obj.TimeoutSeconds = mkintp(120)

+			}

+		},

+	)

+	if err != nil {

+		panic(err)

+	}

+}

new file mode 100644

@@ -0,0 +1,53 @@

+package v1beta3_test

+

+import (

+	"reflect"

+	"testing"

+

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

+

+	newer "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+	current "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta3"

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

+)

+

+func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {

+	data, err := current.Codec.Encode(obj)

+	if err != nil {

+		t.Errorf("%v\n %#v", err, obj)

+		return nil

+	}

+	obj2, err := newer.Codec.Decode(data)

+	if err != nil {

+		t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj)

+		return nil

+	}

+	obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object)

+	err = newer.Scheme.Convert(obj2, obj3)

+	if err != nil {

+		t.Errorf("%v\nSource: %#v", err, obj2)

+		return nil

+	}

+	return obj3

+}

+

+func TestDefaults_rollingParams(t *testing.T) {

+	c := &deployapi.DeploymentConfig{

+		Template: deployapi.DeploymentTemplate{},

+	}

+	o := roundTrip(t, runtime.Object(c))

+	config := o.(*deployapi.DeploymentConfig)

+	strat := config.Template.Strategy

+	if e, a := deployapi.DeploymentStrategyTypeRolling, strat.Type; e != a {

+		t.Errorf("expected strategy type %s, got %s", e, a)

+	}

+	if e, a := int64(1), *strat.RollingParams.UpdatePeriodSeconds; e != a {

+		t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a)

+	}

+	if e, a := int64(1), *strat.RollingParams.IntervalSeconds; e != a {

+		t.Errorf("expected IntervalSeconds %d, got %d", e, a)

+	}

+	if e, a := int64(120), *strat.RollingParams.TimeoutSeconds; e != a {

+		t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a)

+	}

+}

@@ -30,6 +30,8 @@ type DeploymentStrategy struct {

 	CustomParams *CustomDeploymentStrategyParams `json:"customParams,omitempty"`

 	// RecreateParams are the input to the Recreate deployment strategy.

 	RecreateParams *RecreateDeploymentStrategyParams `json:"recreateParams,omitempty"`

+	// RollingParams are the input to the Rolling deployment strategy.

+	RollingParams *RollingDeploymentStrategyParams `json:"rollingParams,omitempty"`

 	// Compute resource requirements to execute the deployment

 	Resources kapi.ResourceRequirements `json:"resources,omitempty"`

 }

@@ -42,6 +44,8 @@ const (

 	DeploymentStrategyTypeRecreate DeploymentStrategyType = "Recreate"

 	// DeploymentStrategyTypeCustom is a user defined strategy.

 	DeploymentStrategyTypeCustom DeploymentStrategyType = "Custom"

+	// DeploymentStrategyTypeRolling uses the Kubernetes RollingUpdater.

+	DeploymentStrategyTypeRolling DeploymentStrategyType = "Rolling"

 )

 // CustomParams are the input to the Custom deployment strategy.

@@ -99,6 +103,20 @@ type ExecNewPodHook struct {

 	ContainerName string `json:"containerName"`

 }

+// RollingDeploymentStrategyParams are the input to the Rolling deployment

+// strategy.

+type RollingDeploymentStrategyParams struct {

+	// UpdatePeriodSeconds is the time to wait between individual pod updates.

+	// If the value is nil, a default will be used.

+	UpdatePeriodSeconds *int64 `json:"updatePeriodSeconds,omitempty" description:"the time to wait between individual pod updates"`

+	// IntervalSeconds is the time to wait between polling deployment status

+	// after update. If the value is nil, a default will be used.

+	IntervalSeconds *int64 `json:"intervalSeconds,omitempty" description:"the time to wait between polling deployment status after update"`

+	// TimeoutSeconds is the time to wait for updates before giving up. If the

+	// value is nil, a default will be used.

+	TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty" description:"the time to wait for updates before giving up"`

+}

+

 // These constants represent keys used for correlating objects related to deployments.

 const (

 	// DeploymentConfigAnnotation is an annotation name used to correlate a deployment with the

@@ -82,6 +82,12 @@ func validateDeploymentStrategy(strategy *deployapi.DeploymentStrategy) fielderr

 		if strategy.RecreateParams != nil {

 			errs = append(errs, validateRecreateParams(strategy.RecreateParams).Prefix("recreateParams")...)

 		}

+	case deployapi.DeploymentStrategyTypeRolling:

+		if strategy.RollingParams == nil {

+			errs = append(errs, fielderrors.NewFieldRequired("rollingParams"))

+		} else {

+			errs = append(errs, validateRollingParams(strategy.RollingParams).Prefix("rollingParams")...)

+		}

 	case deployapi.DeploymentStrategyTypeCustom:

 		if strategy.CustomParams == nil {

 			errs = append(errs, fielderrors.NewFieldRequired("customParams"))

@@ -168,6 +174,24 @@ func validateEnv(vars []kapi.EnvVar) fielderrors.ValidationErrorList {

 	return allErrs

 }

+func validateRollingParams(params *deployapi.RollingDeploymentStrategyParams) fielderrors.ValidationErrorList {

+	errs := fielderrors.ValidationErrorList{}

+

+	if params.IntervalSeconds != nil && *params.IntervalSeconds < 1 {

+		errs = append(errs, fielderrors.NewFieldInvalid("intervalSeconds", *params.IntervalSeconds, "must be >0"))

+	}

+

+	if params.UpdatePeriodSeconds != nil && *params.UpdatePeriodSeconds < 1 {

+		errs = append(errs, fielderrors.NewFieldInvalid("updatePeriodSeconds", *params.UpdatePeriodSeconds, "must be >0"))

+	}

+

+	if params.TimeoutSeconds != nil && *params.TimeoutSeconds < 1 {

+		errs = append(errs, fielderrors.NewFieldInvalid("timeoutSeconds", *params.TimeoutSeconds, "must be >0"))

+	}

+

+	return errs

+}

+

 func validateTrigger(trigger *deployapi.DeploymentTriggerPolicy) fielderrors.ValidationErrorList {

 	errs := fielderrors.ValidationErrorList{}

@@ -328,6 +328,63 @@ func TestValidateDeploymentConfigMissingFields(t *testing.T) {

 			fielderrors.ValidationErrorTypeRequired,

 			"template.strategy.recreateParams.pre.execNewPod.containerName",

 		},

+		"invalid template.strategy.rollingParams.intervalSeconds": {

+			api.DeploymentConfig{

+				ObjectMeta: kapi.ObjectMeta{Name: "foo", Namespace: "bar"},

+				Triggers:   manualTrigger(),

+				Template: api.DeploymentTemplate{

+					Strategy: api.DeploymentStrategy{

+						Type: api.DeploymentStrategyTypeRolling,

+						RollingParams: &api.RollingDeploymentStrategyParams{

+							IntervalSeconds:     mkintp(-20),

+							UpdatePeriodSeconds: mkintp(1),

+							TimeoutSeconds:      mkintp(1),

+						},

+					},

+					ControllerTemplate: test.OkControllerTemplate(),

+				},

+			},

+			fielderrors.ValidationErrorTypeInvalid,

+			"template.strategy.rollingParams.intervalSeconds",

+		},

+		"invalid template.strategy.rollingParams.updatePeriodSeconds": {

+			api.DeploymentConfig{

+				ObjectMeta: kapi.ObjectMeta{Name: "foo", Namespace: "bar"},

+				Triggers:   manualTrigger(),

+				Template: api.DeploymentTemplate{

+					Strategy: api.DeploymentStrategy{

+						Type: api.DeploymentStrategyTypeRolling,

+						RollingParams: &api.RollingDeploymentStrategyParams{

+							IntervalSeconds:     mkintp(1),

+							UpdatePeriodSeconds: mkintp(-20),

+							TimeoutSeconds:      mkintp(1),

+						},

+					},

+					ControllerTemplate: test.OkControllerTemplate(),

+				},

+			},

+			fielderrors.ValidationErrorTypeInvalid,

+			"template.strategy.rollingParams.updatePeriodSeconds",

+		},

+		"invalid template.strategy.rollingParams.timeoutSeconds": {

+			api.DeploymentConfig{

+				ObjectMeta: kapi.ObjectMeta{Name: "foo", Namespace: "bar"},

+				Triggers:   manualTrigger(),

+				Template: api.DeploymentTemplate{

+					Strategy: api.DeploymentStrategy{

+						Type: api.DeploymentStrategyTypeRolling,

+						RollingParams: &api.RollingDeploymentStrategyParams{

+							IntervalSeconds:     mkintp(1),

+							UpdatePeriodSeconds: mkintp(1),

+							TimeoutSeconds:      mkintp(-20),

+						},

+					},

+					ControllerTemplate: test.OkControllerTemplate(),

+				},

+			},

+			fielderrors.ValidationErrorTypeInvalid,

+			"template.strategy.rollingParams.timeoutSeconds",

+		},

 	}

 	for k, v := range errorCases {

@@ -464,3 +521,8 @@ func TestValidateDeploymentConfigImageRepositorySupported(t *testing.T) {

 		t.Errorf("expected imageChangeParams.from.kind %s, got %s", e, a)

 	}

 }

+

+func mkintp(i int) *int64 {

+	v := int64(i)

+	return &v

+}

@@ -28,8 +28,8 @@ type DeploymentControllerFactory struct {

 	Codec runtime.Codec

 	// Environment is a set of environment which should be injected into all deployer pod containers.

 	Environment []kapi.EnvVar

-	// RecreateStrategyImage specifies which Docker image which should implement the Recreate strategy.

-	RecreateStrategyImage string

+	// DeployerImage specifies which Docker image can support the default strategies.

+	DeployerImage string

 }

 // Create creates a DeploymentController.

@@ -100,9 +100,9 @@ func (factory *DeploymentControllerFactory) Create() controller.RunnableControll

 // makeContainer creates containers in the following way:

 //

-//   1. For the Recreate strategy, use the factory's RecreateStrategyImage as

-//      the container image, and the factory's Environment as the container

-//      environment.

+//   1. For the Recreate and Rolling strategies, strategy, use the factory's

+//      DeployerImage as the container image, and the factory's Environment

+//      as the container environment.

 //   2. For all Custom strategy, use the strategy's image for the container

 //      image, and use the combination of the factory's Environment and the

 //      strategy's environment as the container environment.

@@ -117,10 +117,10 @@ func (factory *DeploymentControllerFactory) makeContainer(strategy *deployapi.De

 	// Every strategy type should be handled here.

 	switch strategy.Type {

-	case deployapi.DeploymentStrategyTypeRecreate:

+	case deployapi.DeploymentStrategyTypeRecreate, deployapi.DeploymentStrategyTypeRolling:

 		// Use the factory-configured image.

 		return &kapi.Container{

-			Image: factory.RecreateStrategyImage,

+			Image: factory.DeployerImage,

 			Env:   environment,

 		}, nil

 	case deployapi.DeploymentStrategyTypeCustom:

new file mode 100644

@@ -0,0 +1,11 @@

+package strategy

+

+import (

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+)

+

+// DeploymentStrategy knows how to make a deployment active.

+type DeploymentStrategy interface {

+	// Deploy makes a deployment active.

+	Deploy(deployment *kapi.ReplicationController, oldDeployments []*kapi.ReplicationController) error

+}

@@ -58,7 +58,7 @@ func NewRecreateDeploymentStrategy(client kclient.Interface, codec runtime.Codec

 }

 // Deploy makes deployment active and disables oldDeployments.

-func (s *RecreateDeploymentStrategy) Deploy(deployment *kapi.ReplicationController, oldDeployments []kapi.ObjectReference) error {

+func (s *RecreateDeploymentStrategy) Deploy(deployment *kapi.ReplicationController, oldDeployments []*kapi.ReplicationController) error {

 	var err error

 	var deploymentConfig *deployapi.DeploymentConfig

@@ -40,7 +40,7 @@ func TestRecreate_initialDeployment(t *testing.T) {

 	// Deployment replicas should follow the config as there's no explicit

 	// desired annotation.

 	deployment, _ = deployutil.MakeDeployment(deploytest.OkDeploymentConfig(1), kapi.Codec)

-	err := strategy.Deploy(deployment, []kapi.ObjectReference{})

+	err := strategy.Deploy(deployment, []*kapi.ReplicationController{})

 	if err != nil {

 		t.Fatalf("unexpected deploy error: %#v", err)

 	}

@@ -51,7 +51,7 @@ func TestRecreate_initialDeployment(t *testing.T) {

 	// Deployment replicas should follow the explicit annotation.

 	deployment, _ = deployutil.MakeDeployment(deploytest.OkDeploymentConfig(1), kapi.Codec)

 	deployment.Annotations[deployapi.DesiredReplicasAnnotation] = "2"

-	err = strategy.Deploy(deployment, []kapi.ObjectReference{})

+	err = strategy.Deploy(deployment, []*kapi.ReplicationController{})

 	if err != nil {

 		t.Fatalf("unexpected deploy error: %#v", err)

 	}

@@ -63,7 +63,7 @@ func TestRecreate_initialDeployment(t *testing.T) {

 	// invalid.

 	deployment, _ = deployutil.MakeDeployment(deploytest.OkDeploymentConfig(1), kapi.Codec)

 	deployment.Annotations[deployapi.DesiredReplicasAnnotation] = "invalid"

-	err = strategy.Deploy(deployment, []kapi.ObjectReference{})

+	err = strategy.Deploy(deployment, []*kapi.ReplicationController{})

 	if err != nil {

 		t.Fatalf("unexpected deploy error: %#v", err)

 	}

@@ -112,12 +112,7 @@ func TestRecreate_secondDeploymentWithSuccessfulRetries(t *testing.T) {

 		},

 	}

-	err := strategy.Deploy(newDeployment, []kapi.ObjectReference{

-		{

-			Namespace: oldDeployment.Namespace,

-			Name:      oldDeployment.Name,

-		},

-	})

+	err := strategy.Deploy(newDeployment, []*kapi.ReplicationController{oldDeployment})

 	if err != nil {

 		t.Fatalf("unexpected deploy error: %#v", err)

@@ -165,12 +160,7 @@ func TestRecreate_secondDeploymentScaleUpRetries(t *testing.T) {

 		},

 	}

-	err := strategy.Deploy(newDeployment, []kapi.ObjectReference{

-		{

-			Namespace: oldDeployment.Namespace,

-			Name:      oldDeployment.Name,

-		},

-	})

+	err := strategy.Deploy(newDeployment, []*kapi.ReplicationController{oldDeployment})

 	if err == nil {

 		t.Fatalf("expected a deploy error: %#v", err)

@@ -222,12 +212,7 @@ func TestRecreate_secondDeploymentScaleDownRetries(t *testing.T) {

 		},

 	}

-	err := strategy.Deploy(newDeployment, []kapi.ObjectReference{

-		{

-			Namespace: oldDeployment.Namespace,

-			Name:      oldDeployment.Name,

-		},

-	})