diff --git a/README.md b/README.md
index f44a3b2..228408f 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,9 @@ be specified.
 
 * `manifest`: *Required.* Path to a application manifest file.
 * `path`: *Optional.* Path to the application to push. If this isn't set then
-  it will be read from the manifest instead.
+  it will be read from the manifest instead. When using rolling app deployments, this is required.
+* `use_rolling_app_deployment`: *Optional.* Use CC's native rolling deployments feature to upgrade 
+  the app without downtime. Default false.
 * `current_app_name`: *Optional.* This should be the name of the application
   that this will re-deploy over. If this is set the resource will perform a
   zero-downtime deploy.
diff --git a/out/cloud_foundry.go b/out/cloud_foundry.go
index 7e1ca73..7caecca 100644
--- a/out/cloud_foundry.go
+++ b/out/cloud_foundry.go
@@ -2,16 +2,19 @@ package out
 
 import (
 	"fmt"
-	"github.com/concourse/cf-resource/out/zdt"
 	"os"
 	"os/exec"
+
+	"github.com/concourse/cf-resource/out/zdt"
 )
 
 //go:generate counterfeiter . PAAS
 type PAAS interface {
+	ApplyManifest(currentAppName string, manifest string) error
 	Login(api string, username string, password string, clientID string, clientSecret string, insecure bool) error
 	Target(organization string, space string) error
 	PushApp(manifest string, path string, currentAppName string, vars map[string]interface{}, varsFiles []string, dockerUser string, showLogs bool, noStart bool) error
+	PushAppWithRollingDeployment(path string, currentAppName string, dockerUser string, showLogs bool, noStart bool, manifest string) error
 }
 
 type CloudFoundry struct {
@@ -43,6 +46,22 @@ func (cf *CloudFoundry) Target(organization string, space string) error {
 	return cf.cf("target", "-o", organization, "-s", space).Run()
 }
 
+func (cf *CloudFoundry) PushAppWithRollingDeployment(
+	path string,
+	currentAppName string,
+	dockerUser string,
+	showLogs bool,
+	noStart bool,
+	manifest string,
+) error {
+	cf.cf("version").Run()
+
+	if manifest != "" {
+		cf.ApplyManifest(currentAppName, manifest)
+	}
+	return cf.simpleRollingDeploymentPush(path, currentAppName, dockerUser, noStart)
+}
+
 func (cf *CloudFoundry) PushApp(
 	manifest string,
 	path string,
@@ -53,7 +72,6 @@ func (cf *CloudFoundry) PushApp(
 	showLogs bool,
 	noStart bool,
 ) error {
-
 	if zdt.CanPush(cf.cf, currentAppName) {
 		pushFunction := func() error {
 			return cf.simplePush(manifest, path, currentAppName, vars, varsFiles, dockerUser, noStart)
@@ -115,6 +133,47 @@ func (cf *CloudFoundry) simplePush(
 	return cf.cf(args...).Run()
 }
 
+func (cf *CloudFoundry) ApplyManifest(currentAppName, manifest string) error {
+	return cf.cf("v3-apply-manifest", currentAppName, "-f", manifest).Run()
+}
+
+func (cf *CloudFoundry) simpleRollingDeploymentPush(
+	path string,
+	currentAppName string,
+	dockerUser string,
+	noStart bool,
+) error {
+	args := []string{"v3-zdt-push", "--wait-for-deploy-complete"}
+
+	if currentAppName != "" {
+		args = append(args, currentAppName)
+	}
+
+	if noStart {
+		args = append(args, "--no-start")
+	}
+
+	if dockerUser != "" {
+		args = append(args, "--docker-username", dockerUser)
+	}
+
+	if path != "" {
+		stat, err := os.Stat(path)
+		if err != nil {
+			return err
+		}
+		if stat.IsDir() {
+			args = append(args, "-p", ".")
+			return chdir(path, cf.cf(args...).Run)
+		}
+
+		// path is a zip file, add it to the args
+		args = append(args, "-p", path)
+	}
+
+	return cf.cf(args...).Run()
+}
+
 func chdir(path string, f func() error) error {
 	oldpath, err := os.Getwd()
 	if err != nil {
diff --git a/out/command.go b/out/command.go
index 737197f..8107621 100644
--- a/out/command.go
+++ b/out/command.go
@@ -1,9 +1,8 @@
 package out
 
 import (
-	"time"
-
 	"os"
+	"time"
 
 	"github.com/concourse/cf-resource"
 )
@@ -48,17 +47,27 @@ func (command *Command) Run(request Request) (Response, error) {
 	if request.Params.DockerPassword != "" {
 		os.Setenv(CfDockerPassword, request.Params.DockerPassword)
 	}
-
-	err = command.paas.PushApp(
-		request.Params.ManifestPath,
-		request.Params.Path,
-		request.Params.CurrentAppName,
-		request.Params.Vars,
-		request.Params.VarsFiles,
-		request.Params.DockerUsername,
-		request.Params.ShowAppLog,
-		request.Params.NoStart,
-	)
+	if request.Params.UseRollingAppDeployment {
+		err = command.paas.PushAppWithRollingDeployment(
+			request.Params.Path,
+			request.Params.CurrentAppName,
+			request.Params.DockerUsername,
+			request.Params.ShowAppLog,
+			request.Params.NoStart,
+			request.Params.ManifestPath,
+		)
+	} else {
+		err = command.paas.PushApp(
+			request.Params.ManifestPath,
+			request.Params.Path,
+			request.Params.CurrentAppName,
+			request.Params.Vars,
+			request.Params.VarsFiles,
+			request.Params.DockerUsername,
+			request.Params.ShowAppLog,
+			request.Params.NoStart,
+		)
+	}
 	if err != nil {
 		return Response{}, err
 	}
diff --git a/out/command_test.go b/out/command_test.go
index 581719e..482519a 100644
--- a/out/command_test.go
+++ b/out/command_test.go
@@ -1,3 +1,4 @@
+
 package out_test
 
 import (
@@ -44,6 +45,59 @@ var _ = Describe("Out Command", func() {
 	})
 
 	Describe("running the command", func() {
+		Context("when requesting rolling deployments", func() {
+			BeforeEach(func() {
+				request.Params.UseRollingAppDeployment = true
+			})
+			It("pushes an application using cf v3-zdt-push", func() {
+				response, err := command.Run(request)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(response.Version.Timestamp).To(BeTemporally("~", time.Now(), time.Second))
+				Expect(response.Metadata[0]).To(Equal(
+					resource.MetadataPair{
+						Name:  "organization",
+						Value: "secret",
+					},
+				))
+				Expect(response.Metadata[1]).To(Equal(
+					resource.MetadataPair{
+						Name:  "space",
+						Value: "volcano-base",
+					},
+				))
+
+				By("logging in")
+				Expect(cloudFoundry.LoginCallCount()).To(Equal(1))
+
+				api, username, password, clientID, clientSecret, insecure := cloudFoundry.LoginArgsForCall(0)
+				Expect(api).To(Equal("https://api.run.pivotal.io"))
+				Expect(username).To(Equal("awesome@example.com"))
+				Expect(password).To(Equal("hunter2"))
+				Expect(clientID).To(Equal(""))
+				Expect(clientSecret).To(Equal(""))
+				Expect(insecure).To(Equal(false))
+
+				By("targeting the organization and space")
+				Expect(cloudFoundry.TargetCallCount()).To(Equal(1))
+
+				org, space := cloudFoundry.TargetArgsForCall(0)
+				Expect(org).To(Equal("secret"))
+				Expect(space).To(Equal("volcano-base"))
+
+				By("pushing the app")
+				Expect(cloudFoundry.PushAppCallCount()).To(Equal(0))
+				Expect(cloudFoundry.PushAppWithRollingDeploymentCallCount()).To(Equal(1))
+
+				path, currentAppName, dockerUser, showAppLog, noStart, manifest := cloudFoundry.PushAppWithRollingDeploymentArgsForCall(0)
+				Expect(path).To(Equal(""))
+				Expect(currentAppName).To(Equal(""))
+				Expect(dockerUser).To(Equal(""))
+				Expect(showAppLog).To(Equal(false))
+				Expect(noStart).To(Equal(false))
+				Expect(manifest).To(Equal("assets/manifest.yml"))
+			})
+		})
 		It("pushes an application into cloud foundry", func() {
 			response, err := command.Run(request)
 			Expect(err).NotTo(HaveOccurred())
@@ -82,6 +136,7 @@ var _ = Describe("Out Command", func() {
 
 			By("pushing the app")
 			Expect(cloudFoundry.PushAppCallCount()).To(Equal(1))
+			Expect(cloudFoundry.PushAppWithRollingDeploymentCallCount()).To(Equal(0))
 
 			manifest, path, currentAppName, vars, varsFiles, dockerUser, showAppLog, noStart := cloudFoundry.PushAppArgsForCall(0)
 			Expect(manifest).To(Equal(request.Params.ManifestPath))
diff --git a/out/integration_test.go b/out/integration_test.go
index 60e95a7..67a402f 100644
--- a/out/integration_test.go
+++ b/out/integration_test.go
@@ -93,6 +93,8 @@ var _ = Describe("Out", func() {
 
 	Context("when my manifest and paths do not contain a glob", func() {
 		It("pushes an application to cloud foundry", func() {
+			fmt.Printf("command: %s\n", binPath)
+
 			session, err := gexec.Start(
 				cmd,
 				GinkgoWriter,
diff --git a/out/models.go b/out/models.go
index aa09655..c4b2cd2 100644
--- a/out/models.go
+++ b/out/models.go
@@ -8,16 +8,17 @@ type Request struct {
 }
 
 type Params struct {
-	ManifestPath         string                 `json:"manifest"`
-	Path                 string                 `json:"path"`
-	CurrentAppName       string                 `json:"current_app_name"`
-	Vars                 map[string]interface{} `json:"vars"`
-	VarsFiles            []string               `json:"vars_files"`
-	EnvironmentVariables map[string]string      `json:"environment_variables"`
-	DockerUsername       string                 `json:"docker_username"`
-	DockerPassword       string                 `json:"docker_password"`
-	ShowAppLog           bool                   `json:"show_app_log"`
-	NoStart              bool                   `json:"no_start"`
+	ManifestPath            string                 `json:"manifest"`
+	Path                    string                 `json:"path"`
+	CurrentAppName          string                 `json:"current_app_name"`
+	Vars                    map[string]interface{} `json:"vars"`
+	VarsFiles               []string               `json:"vars_files"`
+	EnvironmentVariables    map[string]string      `json:"environment_variables"`
+	DockerUsername          string                 `json:"docker_username"`
+	DockerPassword          string                 `json:"docker_password"`
+	ShowAppLog              bool                   `json:"show_app_log"`
+	NoStart                 bool                   `json:"no_start"`
+	UseRollingAppDeployment bool                   `json:"use_rolling_app_deployment"`
 }
 
 type Response struct {
diff --git a/out/outfakes/fake_paas.go b/out/outfakes/fake_paas.go
index 3e9e17e..8ec0e35 100644
--- a/out/outfakes/fake_paas.go
+++ b/out/outfakes/fake_paas.go
@@ -8,15 +8,27 @@ import (
 )
 
 type FakePAAS struct {
-	LoginStub        func(api string, username string, password string, clientID string, clientSecret string, insecure bool) error
+	ApplyManifestStub        func(string, string) error
+	applyManifestMutex       sync.RWMutex
+	applyManifestArgsForCall []struct {
+		arg1 string
+		arg2 string
+	}
+	applyManifestReturns struct {
+		result1 error
+	}
+	applyManifestReturnsOnCall map[int]struct {
+		result1 error
+	}
+	LoginStub        func(string, string, string, string, string, bool) error
 	loginMutex       sync.RWMutex
 	loginArgsForCall []struct {
-		api          string
-		username     string
-		password     string
-		clientID     string
-		clientSecret string
-		insecure     bool
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 string
+		arg5 string
+		arg6 bool
 	}
 	loginReturns struct {
 		result1 error
@@ -24,11 +36,45 @@ type FakePAAS struct {
 	loginReturnsOnCall map[int]struct {
 		result1 error
 	}
-	TargetStub        func(organization string, space string) error
+	PushAppStub        func(string, string, string, map[string]interface{}, []string, string, bool, bool) error
+	pushAppMutex       sync.RWMutex
+	pushAppArgsForCall []struct {
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 map[string]interface{}
+		arg5 []string
+		arg6 string
+		arg7 bool
+		arg8 bool
+	}
+	pushAppReturns struct {
+		result1 error
+	}
+	pushAppReturnsOnCall map[int]struct {
+		result1 error
+	}
+	PushAppWithRollingDeploymentStub        func(string, string, string, bool, bool, string) error
+	pushAppWithRollingDeploymentMutex       sync.RWMutex
+	pushAppWithRollingDeploymentArgsForCall []struct {
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 bool
+		arg5 bool
+		arg6 string
+	}
+	pushAppWithRollingDeploymentReturns struct {
+		result1 error
+	}
+	pushAppWithRollingDeploymentReturnsOnCall map[int]struct {
+		result1 error
+	}
+	TargetStub        func(string, string) error
 	targetMutex       sync.RWMutex
 	targetArgsForCall []struct {
-		organization string
-		space        string
+		arg1 string
+		arg2 string
 	}
 	targetReturns struct {
 		result1 error
@@ -36,48 +82,92 @@ type FakePAAS struct {
 	targetReturnsOnCall map[int]struct {
 		result1 error
 	}
-	PushAppStub        func(manifest string, path string, currentAppName string, vars map[string]interface{}, varsFiles []string, dockerUser string, showLogs bool, noStart bool) error
-	pushAppMutex       sync.RWMutex
-	pushAppArgsForCall []struct {
-		manifest       string
-		path           string
-		currentAppName string
-		vars           map[string]interface{}
-		varsFiles      []string
-		dockerUser     string
-		showLogs       bool
-		noStart        bool
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakePAAS) ApplyManifest(arg1 string, arg2 string) error {
+	fake.applyManifestMutex.Lock()
+	ret, specificReturn := fake.applyManifestReturnsOnCall[len(fake.applyManifestArgsForCall)]
+	fake.applyManifestArgsForCall = append(fake.applyManifestArgsForCall, struct {
+		arg1 string
+		arg2 string
+	}{arg1, arg2})
+	fake.recordInvocation("ApplyManifest", []interface{}{arg1, arg2})
+	fake.applyManifestMutex.Unlock()
+	if fake.ApplyManifestStub != nil {
+		return fake.ApplyManifestStub(arg1, arg2)
 	}
-	pushAppReturns struct {
-		result1 error
+	if specificReturn {
+		return ret.result1
 	}
-	pushAppReturnsOnCall map[int]struct {
+	fakeReturns := fake.applyManifestReturns
+	return fakeReturns.result1
+}
+
+func (fake *FakePAAS) ApplyManifestCallCount() int {
+	fake.applyManifestMutex.RLock()
+	defer fake.applyManifestMutex.RUnlock()
+	return len(fake.applyManifestArgsForCall)
+}
+
+func (fake *FakePAAS) ApplyManifestCalls(stub func(string, string) error) {
+	fake.applyManifestMutex.Lock()
+	defer fake.applyManifestMutex.Unlock()
+	fake.ApplyManifestStub = stub
+}
+
+func (fake *FakePAAS) ApplyManifestArgsForCall(i int) (string, string) {
+	fake.applyManifestMutex.RLock()
+	defer fake.applyManifestMutex.RUnlock()
+	argsForCall := fake.applyManifestArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakePAAS) ApplyManifestReturns(result1 error) {
+	fake.applyManifestMutex.Lock()
+	defer fake.applyManifestMutex.Unlock()
+	fake.ApplyManifestStub = nil
+	fake.applyManifestReturns = struct {
 		result1 error
+	}{result1}
+}
+
+func (fake *FakePAAS) ApplyManifestReturnsOnCall(i int, result1 error) {
+	fake.applyManifestMutex.Lock()
+	defer fake.applyManifestMutex.Unlock()
+	fake.ApplyManifestStub = nil
+	if fake.applyManifestReturnsOnCall == nil {
+		fake.applyManifestReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
 	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
+	fake.applyManifestReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
 }
 
-func (fake *FakePAAS) Login(api string, username string, password string, clientID string, clientSecret string, insecure bool) error {
+func (fake *FakePAAS) Login(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string, arg6 bool) error {
 	fake.loginMutex.Lock()
 	ret, specificReturn := fake.loginReturnsOnCall[len(fake.loginArgsForCall)]
 	fake.loginArgsForCall = append(fake.loginArgsForCall, struct {
-		api          string
-		username     string
-		password     string
-		clientID     string
-		clientSecret string
-		insecure     bool
-	}{api, username, password, clientID, clientSecret, insecure})
-	fake.recordInvocation("Login", []interface{}{api, username, password, clientID, clientSecret, insecure})
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 string
+		arg5 string
+		arg6 bool
+	}{arg1, arg2, arg3, arg4, arg5, arg6})
+	fake.recordInvocation("Login", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
 	fake.loginMutex.Unlock()
 	if fake.LoginStub != nil {
-		return fake.LoginStub(api, username, password, clientID, clientSecret, insecure)
+		return fake.LoginStub(arg1, arg2, arg3, arg4, arg5, arg6)
 	}
 	if specificReturn {
 		return ret.result1
 	}
-	return fake.loginReturns.result1
+	fakeReturns := fake.loginReturns
+	return fakeReturns.result1
 }
 
 func (fake *FakePAAS) LoginCallCount() int {
@@ -86,13 +176,22 @@ func (fake *FakePAAS) LoginCallCount() int {
 	return len(fake.loginArgsForCall)
 }
 
+func (fake *FakePAAS) LoginCalls(stub func(string, string, string, string, string, bool) error) {
+	fake.loginMutex.Lock()
+	defer fake.loginMutex.Unlock()
+	fake.LoginStub = stub
+}
+
 func (fake *FakePAAS) LoginArgsForCall(i int) (string, string, string, string, string, bool) {
 	fake.loginMutex.RLock()
 	defer fake.loginMutex.RUnlock()
-	return fake.loginArgsForCall[i].api, fake.loginArgsForCall[i].username, fake.loginArgsForCall[i].password, fake.loginArgsForCall[i].clientID, fake.loginArgsForCall[i].clientSecret, fake.loginArgsForCall[i].insecure
+	argsForCall := fake.loginArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
 }
 
 func (fake *FakePAAS) LoginReturns(result1 error) {
+	fake.loginMutex.Lock()
+	defer fake.loginMutex.Unlock()
 	fake.LoginStub = nil
 	fake.loginReturns = struct {
 		result1 error
@@ -100,6 +199,8 @@ func (fake *FakePAAS) LoginReturns(result1 error) {
 }
 
 func (fake *FakePAAS) LoginReturnsOnCall(i int, result1 error) {
+	fake.loginMutex.Lock()
+	defer fake.loginMutex.Unlock()
 	fake.LoginStub = nil
 	if fake.loginReturnsOnCall == nil {
 		fake.loginReturnsOnCall = make(map[int]struct {
@@ -111,111 +212,200 @@ func (fake *FakePAAS) LoginReturnsOnCall(i int, result1 error) {
 	}{result1}
 }
 
-func (fake *FakePAAS) Target(organization string, space string) error {
-	fake.targetMutex.Lock()
-	ret, specificReturn := fake.targetReturnsOnCall[len(fake.targetArgsForCall)]
-	fake.targetArgsForCall = append(fake.targetArgsForCall, struct {
-		organization string
-		space        string
-	}{organization, space})
-	fake.recordInvocation("Target", []interface{}{organization, space})
-	fake.targetMutex.Unlock()
-	if fake.TargetStub != nil {
-		return fake.TargetStub(organization, space)
+func (fake *FakePAAS) PushApp(arg1 string, arg2 string, arg3 string, arg4 map[string]interface{}, arg5 []string, arg6 string, arg7 bool, arg8 bool) error {
+	var arg5Copy []string
+	if arg5 != nil {
+		arg5Copy = make([]string, len(arg5))
+		copy(arg5Copy, arg5)
+	}
+	fake.pushAppMutex.Lock()
+	ret, specificReturn := fake.pushAppReturnsOnCall[len(fake.pushAppArgsForCall)]
+	fake.pushAppArgsForCall = append(fake.pushAppArgsForCall, struct {
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 map[string]interface{}
+		arg5 []string
+		arg6 string
+		arg7 bool
+		arg8 bool
+	}{arg1, arg2, arg3, arg4, arg5Copy, arg6, arg7, arg8})
+	fake.recordInvocation("PushApp", []interface{}{arg1, arg2, arg3, arg4, arg5Copy, arg6, arg7, arg8})
+	fake.pushAppMutex.Unlock()
+	if fake.PushAppStub != nil {
+		return fake.PushAppStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 	}
 	if specificReturn {
 		return ret.result1
 	}
-	return fake.targetReturns.result1
+	fakeReturns := fake.pushAppReturns
+	return fakeReturns.result1
 }
 
-func (fake *FakePAAS) TargetCallCount() int {
-	fake.targetMutex.RLock()
-	defer fake.targetMutex.RUnlock()
-	return len(fake.targetArgsForCall)
+func (fake *FakePAAS) PushAppCallCount() int {
+	fake.pushAppMutex.RLock()
+	defer fake.pushAppMutex.RUnlock()
+	return len(fake.pushAppArgsForCall)
 }
 
-func (fake *FakePAAS) TargetArgsForCall(i int) (string, string) {
-	fake.targetMutex.RLock()
-	defer fake.targetMutex.RUnlock()
-	return fake.targetArgsForCall[i].organization, fake.targetArgsForCall[i].space
+func (fake *FakePAAS) PushAppCalls(stub func(string, string, string, map[string]interface{}, []string, string, bool, bool) error) {
+	fake.pushAppMutex.Lock()
+	defer fake.pushAppMutex.Unlock()
+	fake.PushAppStub = stub
 }
 
-func (fake *FakePAAS) TargetReturns(result1 error) {
-	fake.TargetStub = nil
-	fake.targetReturns = struct {
+func (fake *FakePAAS) PushAppArgsForCall(i int) (string, string, string, map[string]interface{}, []string, string, bool, bool) {
+	fake.pushAppMutex.RLock()
+	defer fake.pushAppMutex.RUnlock()
+	argsForCall := fake.pushAppArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8
+}
+
+func (fake *FakePAAS) PushAppReturns(result1 error) {
+	fake.pushAppMutex.Lock()
+	defer fake.pushAppMutex.Unlock()
+	fake.PushAppStub = nil
+	fake.pushAppReturns = struct {
 		result1 error
 	}{result1}
 }
 
-func (fake *FakePAAS) TargetReturnsOnCall(i int, result1 error) {
-	fake.TargetStub = nil
-	if fake.targetReturnsOnCall == nil {
-		fake.targetReturnsOnCall = make(map[int]struct {
+func (fake *FakePAAS) PushAppReturnsOnCall(i int, result1 error) {
+	fake.pushAppMutex.Lock()
+	defer fake.pushAppMutex.Unlock()
+	fake.PushAppStub = nil
+	if fake.pushAppReturnsOnCall == nil {
+		fake.pushAppReturnsOnCall = make(map[int]struct {
 			result1 error
 		})
 	}
-	fake.targetReturnsOnCall[i] = struct {
+	fake.pushAppReturnsOnCall[i] = struct {
 		result1 error
 	}{result1}
 }
 
-func (fake *FakePAAS) PushApp(manifest string, path string, currentAppName string, vars map[string]interface{}, varsFiles []string, dockerUser string, showLogs bool, noStart bool) error {
-	var varsFilesCopy []string
-	if varsFiles != nil {
-		varsFilesCopy = make([]string, len(varsFiles))
-		copy(varsFilesCopy, varsFiles)
+func (fake *FakePAAS) PushAppWithRollingDeployment(arg1 string, arg2 string, arg3 string, arg4 bool, arg5 bool, arg6 string) error {
+	fake.pushAppWithRollingDeploymentMutex.Lock()
+	ret, specificReturn := fake.pushAppWithRollingDeploymentReturnsOnCall[len(fake.pushAppWithRollingDeploymentArgsForCall)]
+	fake.pushAppWithRollingDeploymentArgsForCall = append(fake.pushAppWithRollingDeploymentArgsForCall, struct {
+		arg1 string
+		arg2 string
+		arg3 string
+		arg4 bool
+		arg5 bool
+		arg6 string
+	}{arg1, arg2, arg3, arg4, arg5, arg6})
+	fake.recordInvocation("PushAppWithRollingDeployment", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
+	fake.pushAppWithRollingDeploymentMutex.Unlock()
+	if fake.PushAppWithRollingDeploymentStub != nil {
+		return fake.PushAppWithRollingDeploymentStub(arg1, arg2, arg3, arg4, arg5, arg6)
 	}
-	fake.pushAppMutex.Lock()
-	ret, specificReturn := fake.pushAppReturnsOnCall[len(fake.pushAppArgsForCall)]
-	fake.pushAppArgsForCall = append(fake.pushAppArgsForCall, struct {
-		manifest       string
-		path           string
-		currentAppName string
-		vars           map[string]interface{}
-		varsFiles      []string
-		dockerUser     string
-		showLogs       bool
-		noStart        bool
-	}{manifest, path, currentAppName, vars, varsFilesCopy, dockerUser, showLogs, noStart})
-	fake.recordInvocation("PushApp", []interface{}{manifest, path, currentAppName, vars, varsFilesCopy, dockerUser, showLogs, noStart})
-	fake.pushAppMutex.Unlock()
-	if fake.PushAppStub != nil {
-		return fake.PushAppStub(manifest, path, currentAppName, vars, varsFiles, dockerUser, showLogs, noStart)
+	if specificReturn {
+		return ret.result1
+	}
+	fakeReturns := fake.pushAppWithRollingDeploymentReturns
+	return fakeReturns.result1
+}
+
+func (fake *FakePAAS) PushAppWithRollingDeploymentCallCount() int {
+	fake.pushAppWithRollingDeploymentMutex.RLock()
+	defer fake.pushAppWithRollingDeploymentMutex.RUnlock()
+	return len(fake.pushAppWithRollingDeploymentArgsForCall)
+}
+
+func (fake *FakePAAS) PushAppWithRollingDeploymentCalls(stub func(string, string, string, bool, bool, string) error) {
+	fake.pushAppWithRollingDeploymentMutex.Lock()
+	defer fake.pushAppWithRollingDeploymentMutex.Unlock()
+	fake.PushAppWithRollingDeploymentStub = stub
+}
+
+func (fake *FakePAAS) PushAppWithRollingDeploymentArgsForCall(i int) (string, string, string, bool, bool, string) {
+	fake.pushAppWithRollingDeploymentMutex.RLock()
+	defer fake.pushAppWithRollingDeploymentMutex.RUnlock()
+	argsForCall := fake.pushAppWithRollingDeploymentArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
+}
+
+func (fake *FakePAAS) PushAppWithRollingDeploymentReturns(result1 error) {
+	fake.pushAppWithRollingDeploymentMutex.Lock()
+	defer fake.pushAppWithRollingDeploymentMutex.Unlock()
+	fake.PushAppWithRollingDeploymentStub = nil
+	fake.pushAppWithRollingDeploymentReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakePAAS) PushAppWithRollingDeploymentReturnsOnCall(i int, result1 error) {
+	fake.pushAppWithRollingDeploymentMutex.Lock()
+	defer fake.pushAppWithRollingDeploymentMutex.Unlock()
+	fake.PushAppWithRollingDeploymentStub = nil
+	if fake.pushAppWithRollingDeploymentReturnsOnCall == nil {
+		fake.pushAppWithRollingDeploymentReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.pushAppWithRollingDeploymentReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakePAAS) Target(arg1 string, arg2 string) error {
+	fake.targetMutex.Lock()
+	ret, specificReturn := fake.targetReturnsOnCall[len(fake.targetArgsForCall)]
+	fake.targetArgsForCall = append(fake.targetArgsForCall, struct {
+		arg1 string
+		arg2 string
+	}{arg1, arg2})
+	fake.recordInvocation("Target", []interface{}{arg1, arg2})
+	fake.targetMutex.Unlock()
+	if fake.TargetStub != nil {
+		return fake.TargetStub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1
 	}
-	return fake.pushAppReturns.result1
+	fakeReturns := fake.targetReturns
+	return fakeReturns.result1
 }
 
-func (fake *FakePAAS) PushAppCallCount() int {
-	fake.pushAppMutex.RLock()
-	defer fake.pushAppMutex.RUnlock()
-	return len(fake.pushAppArgsForCall)
+func (fake *FakePAAS) TargetCallCount() int {
+	fake.targetMutex.RLock()
+	defer fake.targetMutex.RUnlock()
+	return len(fake.targetArgsForCall)
 }
 
-func (fake *FakePAAS) PushAppArgsForCall(i int) (string, string, string, map[string]interface{}, []string, string, bool, bool) {
-	fake.pushAppMutex.RLock()
-	defer fake.pushAppMutex.RUnlock()
-	return fake.pushAppArgsForCall[i].manifest, fake.pushAppArgsForCall[i].path, fake.pushAppArgsForCall[i].currentAppName, fake.pushAppArgsForCall[i].vars, fake.pushAppArgsForCall[i].varsFiles, fake.pushAppArgsForCall[i].dockerUser, fake.pushAppArgsForCall[i].showLogs, fake.pushAppArgsForCall[i].noStart
+func (fake *FakePAAS) TargetCalls(stub func(string, string) error) {
+	fake.targetMutex.Lock()
+	defer fake.targetMutex.Unlock()
+	fake.TargetStub = stub
 }
 
-func (fake *FakePAAS) PushAppReturns(result1 error) {
-	fake.PushAppStub = nil
-	fake.pushAppReturns = struct {
+func (fake *FakePAAS) TargetArgsForCall(i int) (string, string) {
+	fake.targetMutex.RLock()
+	defer fake.targetMutex.RUnlock()
+	argsForCall := fake.targetArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakePAAS) TargetReturns(result1 error) {
+	fake.targetMutex.Lock()
+	defer fake.targetMutex.Unlock()
+	fake.TargetStub = nil
+	fake.targetReturns = struct {
 		result1 error
 	}{result1}
 }
 
-func (fake *FakePAAS) PushAppReturnsOnCall(i int, result1 error) {
-	fake.PushAppStub = nil
-	if fake.pushAppReturnsOnCall == nil {
-		fake.pushAppReturnsOnCall = make(map[int]struct {
+func (fake *FakePAAS) TargetReturnsOnCall(i int, result1 error) {
+	fake.targetMutex.Lock()
+	defer fake.targetMutex.Unlock()
+	fake.TargetStub = nil
+	if fake.targetReturnsOnCall == nil {
+		fake.targetReturnsOnCall = make(map[int]struct {
 			result1 error
 		})
 	}
-	fake.pushAppReturnsOnCall[i] = struct {
+	fake.targetReturnsOnCall[i] = struct {
 		result1 error
 	}{result1}
 }
@@ -223,12 +413,16 @@ func (fake *FakePAAS) PushAppReturnsOnCall(i int, result1 error) {
 func (fake *FakePAAS) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
+	fake.applyManifestMutex.RLock()
+	defer fake.applyManifestMutex.RUnlock()
 	fake.loginMutex.RLock()
 	defer fake.loginMutex.RUnlock()
-	fake.targetMutex.RLock()
-	defer fake.targetMutex.RUnlock()
 	fake.pushAppMutex.RLock()
 	defer fake.pushAppMutex.RUnlock()
+	fake.pushAppWithRollingDeploymentMutex.RLock()
+	defer fake.pushAppWithRollingDeploymentMutex.RUnlock()
+	fake.targetMutex.RLock()
+	defer fake.targetMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value