chore(TNZ-44895): Create a recreate deployment action for the cc_deployment_updater

Author: PeteLevineA

app/actions/deployment_create.rb

@@ -247,8 +247,11 @@ def starting_process_instances(deployment, desired_instances)
                                  else
                                    desired_instances
                                  end
-
-        [deployment.max_in_flight, starting_process_count].min
+        if deployment.strategy == DeploymentModel::RECREATE_STRATEGY
+          starting_process_count
+        else
+          [deployment.max_in_flight, starting_process_count].min
+        end
       end
 
       def log_rollback_event(app_guid, user_id, revision_id, strategy, max_in_flight, canary_steps)

lib/cloud_controller/deployment_updater/actions/recreate.rb

@@ -0,0 +1,86 @@
+require 'cloud_controller/deployment_updater/actions/scale_down_canceled_processes'
+require 'cloud_controller/deployment_updater/actions/finalize'
+require 'cloud_controller/deployment_updater/actions/down_scaler'
+require 'cloud_controller/deployment_updater/actions/up_scaler'
+require 'cloud_controller/diego/constants'
+
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class Recreate
+        attr_reader :deployment, :logger, :app, :target_total_instance_count, :interim_desired_instance_count
+
+        def initialize(deployment, logger, target_total_instance_count, interim_desired_instance_count=nil)
+          @deployment = deployment
+          @logger = logger
+          @app = deployment.app
+          @target_total_instance_count = target_total_instance_count
+          @interim_desired_instance_count = interim_desired_instance_count || target_total_instance_count
+        end
+
+        def call
+          logger.info("RECREATE Starting down scaler #{deployment.guid}")
+          down_scaler = DownScaler.new(deployment, logger, target_total_instance_count, instance_count_summary.routable_instances_count)
+          logger.info("RECREATE starting db transaction for #{deployment.guid}")
+          deployment.db.transaction do
+            return unless [DeploymentModel::DEPLOYING_STATE, DeploymentModel::PREPAUSED_STATE].include?(deployment.lock!.state)
+            return unless can_scale? || down_scaler.can_downscale?
+
+            logger.info("RECREATE lock the app for #{deployment.guid}")
+            app.lock!
+            logger.info("RECREATE lock the web_processes for #{deployment.guid}")
+            app.web_processes.each(&:lock!)
+            logger.info("RECREATE set status to active/deploying for #{deployment.guid}")
+            deployment.update(
+              status_value: DeploymentModel::ACTIVE_STATUS_VALUE,
+              status_reason: DeploymentModel::DEPLOYING_STATUS_REASON,
+              error: nil
+            )
+            logger.info("RECREATE scale down canceled processes for #{deployment.guid}")
+            ScaleDownCanceledProcesses.new(deployment).call
+            logger.info("RECREATE scale down web processes for #{deployment.guid}")
+            down_scaler.scale_down if down_scaler.can_downscale?
+            logger.info("are we finished scaling for #{deployment.guid}")
+            return true if finished_scaling?
+
+            logger.info("not finished scaling, scaling up web processes  for #{deployment.guid}")
+            scale_up if can_scale?
+          end
+          false
+        rescue CloudController::Errors::ApiError # the instances_reporter re-raises InstancesUnavailable as ApiError
+          logger.info("skipping-deployment-update-for-#{deployment.guid}")
+          false
+        end
+
+        private
+
+        def scale_up
+          return unless can_scale?
+
+          deploying_web_process.update(instances: desired_new_instances)
+          deployment.update(last_healthy_at: Time.now)
+        end
+
+        def instance_count_summary
+          @instance_count_summary ||= instance_reporters.instance_count_summary(deploying_web_process)
+        end
+
+        def deploying_web_process
+          @deploying_web_process ||= deployment.deploying_web_process
+        end
+
+        def instance_reporters
+          CloudController::DependencyLocator.instance.instances_reporters
+        end
+
+        def can_scale
+          deploying_web_process.instances < interim_desired_instance_count && @routable_instances_count < interim_desired_instance_count
+        end
+
+        def finished_scaling
+          deploying_web_process.instances >= interim_desired_instance_count && @routable_instances_count >= interim_desired_instance_count
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/scale.rb

@@ -19,7 +19,9 @@ def initialize(deployment, logger, target_total_instance_count, interim_desired_
         end
 
         def call
+          logger.info("Starting down scaler #{deployment.guid}")
           down_scaler = DownScaler.new(deployment, logger, target_total_instance_count, instance_count_summary.routable_instances_count)
+          logger.info("Starting up scaler #{deployment.guid}")
           up_scaler = UpScaler.new(deployment, logger, interim_desired_instance_count, instance_count_summary)
 
           deployment.db.transaction do

lib/cloud_controller/deployment_updater/updater.rb

@@ -14,7 +14,13 @@ def initialize(deployment, logger)
 
       def scale
         with_error_logging('error-scaling-deployment') do
-          finished = Actions::Scale.new(deployment, logger, deployment.desired_web_instances).call
+          if deployment.strategy == DeploymentModel::RECREATE_STRATEGY
+            logger.info("recreating deployment for -#{deployment.guid}")
+            finished = Actions::Recreate.new(deployment, logger, deployment.desired_web_instances).call
+          else
+            finished = Actions::Scale.new(deployment, logger, deployment.desired_web_instances).call
+          end
+
           Actions::Finalize.new(deployment).call if finished
           logger.info("ran-deployment-update-for-#{deployment.guid}")
         end

spec/unit/actions/deployment_create_spec.rb

@@ -42,6 +42,15 @@ module VCAP::CloudController
                                   })
     end
 
+    let(:recreate_message) do
+      DeploymentCreateMessage.new({
+                                    relationships: { app: { data: { guid: app.guid } } },
+                                    droplet: { guid: next_droplet.guid },
+                                    strategy: 'recreate',
+                                    options: { web_instances:, memory_in_mb:, disk_in_mb:, log_rate_limit_in_bytes_per_second: }
+                                  })
+    end
+
     before do
       app.update(droplet: original_droplet)
     end
@@ -350,6 +359,32 @@ module VCAP::CloudController
             ).to contain_exactly(deployment.deploying_web_process.type)
           end
 
+          it 'when the strategy is recreate' do
+            deployment = DeploymentCreate.create(app: app, message: recreate_message, user_audit_info: user_audit_info)
+            event = VCAP::CloudController::Event.find(type: 'audit.app.deployment.create')
+            expect(event).not_to be_nil
+            expect(event.actor).to eq('123')
+            expect(event.actor_type).to eq('user')
+            expect(event.actor_name).to eq('[email protected]')
+            expect(event.actor_username).to eq('braa')
+            expect(event.actee).to eq(app.guid)
+            expect(event.actee_type).to eq('app')
+            expect(event.actee_name).to eq(app.name)
+            expect(event.timestamp).to be
+            expect(event.space_guid).to eq(app.space_guid)
+            expect(event.organization_guid).to eq(app.space.organization.guid)
+            expect(event.metadata).to eq({
+                                           'droplet_guid' => next_droplet.guid,
+                                           'deployment_guid' => deployment.guid,
+                                           'type' => nil,
+                                           'revision_guid' => app.latest_revision.guid,
+                                           'request' => message.audit_hash,
+                                           'strategy' => 'recreate'
+                                         })
+
+            expect(deployment.deploying_web_process.instances).to eq(2)
+          end
+
           context 'when the app does not have a droplet set' do
             let(:app_without_current_droplet) { AppModel.make }
             let(:next_droplet) { DropletModel.make(app: app_without_current_droplet, process_types: { 'web' => 'asdf' }) }