Deployment updater refactor (#4101)

* moved different update methods into their own classes (scale, canary, etc)

Author: sethboyles

lib/cloud_controller/deployment_updater/actions/canary.rb

@@ -0,0 +1,48 @@
+require 'cloud_controller/deployment_updater/actions/scale_down_canceled_processes'
+
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class Canary
+        attr_reader :deployment, :logger
+
+        def initialize(deployment, logger)
+          @deployment = deployment
+          @logger = logger
+        end
+
+        def call
+          deployment.db.transaction do
+            deployment.lock!
+            return unless deployment.state == DeploymentModel::PREPAUSED_STATE
+            return unless all_instances_routable?
+
+            ScaleDownCanceledProcesses.new(deployment).call
+
+            deployment.update(
+              last_healthy_at: Time.now,
+              state: DeploymentModel::PAUSED_STATE,
+              status_value: DeploymentModel::ACTIVE_STATUS_VALUE,
+              status_reason: DeploymentModel::PAUSED_STATUS_REASON
+            )
+            logger.info("paused-canary-deployment-for-#{deployment.guid}")
+          end
+        end
+
+        private
+
+        def all_instances_routable?
+          instances = instance_reporters.all_instances_for_app(deployment.deploying_web_process)
+          instances.all? { |_, val| val[:state] == VCAP::CloudController::Diego::LRP_RUNNING && val[:routable] }
+        rescue CloudController::Errors::ApiError # the instances_reporter re-raises InstancesUnavailable as ApiError
+          logger.info("skipping-canary-update-for-#{deployment.guid}")
+          false
+        end
+
+        def instance_reporters
+          CloudController::DependencyLocator.instance.instances_reporters
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/cancel.rb

@@ -0,0 +1,63 @@
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class Cancel
+        attr_reader :deployment, :logger, :app, :deploying_web_process
+
+        def initialize(deployment, logger)
+          @deployment = deployment
+          @logger = logger
+          @app = deployment.app
+          @deploying_web_process = deployment.deploying_web_process
+        end
+
+        def call
+          deployment.db.transaction do
+            app.lock!
+            return unless deployment.lock!.state == DeploymentModel::CANCELING_STATE
+
+            deploying_web_process.lock!
+
+            prior_web_process = find_interim_web_process || app.oldest_web_process
+            prior_web_process.lock!
+
+            prior_web_process.update(instances: deployment.original_web_process_instance_count)
+
+            app.web_processes.reject { |p| p.guid == prior_web_process.guid }.map(&:destroy)
+
+            deployment.update(
+              state: DeploymentModel::CANCELED_STATE,
+              status_value: DeploymentModel::FINALIZED_STATUS_VALUE,
+              status_reason: DeploymentModel::CANCELED_STATUS_REASON
+            )
+          end
+        end
+
+        private
+
+        def find_interim_web_process
+          # Find newest interim web process that (a) belongs to a SUPERSEDED (DEPLOYED) deployment and (b) has at least
+          # one running instance.
+          app.web_processes_dataset.
+            qualify.
+            join(:deployments, deploying_web_process_guid: :guid).
+            where(deployments__state: DeploymentModel::DEPLOYED_STATE).
+            where(deployments__status_reason: DeploymentModel::SUPERSEDED_STATUS_REASON).
+            order(Sequel.desc(:created_at), Sequel.desc(:id)).
+            find { |p| has_running_instance?(p) }
+        end
+
+        def has_running_instance?(process)
+          instances = instance_reporters.all_instances_for_app(process)
+          instances.any? { |_, val| val[:state] == VCAP::CloudController::Diego::LRP_RUNNING }
+        rescue CloudController::Errors::ApiError # the instances_reporter re-raises InstancesUnavailable as ApiError
+          false
+        end
+
+        def instance_reporters
+          CloudController::DependencyLocator.instance.instances_reporters
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/finalize.rb

@@ -0,0 +1,48 @@
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class Finalize
+        attr_reader :deployment, :deploying_web_process, :app
+
+        def initialize(deployment)
+          @deployment = deployment
+          @app = deployment.app
+          @deploying_web_process = deployment.deploying_web_process
+        end
+
+        def call
+          app.web_processes.reject { |p| p.guid == deploying_web_process.guid }.map(&:destroy)
+
+          update_non_web_processes
+          restart_non_web_processes
+          deployment.update(
+            state: DeploymentModel::DEPLOYED_STATE,
+            status_value: DeploymentModel::FINALIZED_STATUS_VALUE,
+            status_reason: DeploymentModel::DEPLOYED_STATUS_REASON
+          )
+        end
+
+        private
+
+        def update_non_web_processes
+          return if deploying_web_process.revision.nil?
+
+          app.processes.reject(&:web?).each do |process|
+            process.update(command: deploying_web_process.revision.commands_by_process_type[process.type])
+          end
+        end
+
+        def restart_non_web_processes
+          app.processes.reject(&:web?).each do |process|
+            VCAP::CloudController::ProcessRestart.restart(
+              process: process,
+              config: Config.config,
+              stop_in_runtime: true,
+              revision: deploying_web_process.revision
+            )
+          end
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/scale.rb

@@ -0,0 +1,77 @@
+require 'cloud_controller/deployment_updater/actions/scale_down_canceled_processes'
+require 'cloud_controller/deployment_updater/actions/scale_down_old_process'
+require 'cloud_controller/deployment_updater/actions/finalize'
+
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class Scale
+        attr_reader :deployment, :logger, :app
+
+        def initialize(deployment, logger)
+          @deployment = deployment
+          @logger = logger
+          @app = deployment.app
+        end
+
+        def call
+          deployment.db.transaction do
+            return unless deployment.lock!.state == DeploymentModel::DEPLOYING_STATE
+            return unless all_instances_routable?
+
+            app.lock!
+            oldest_web_process_with_instances.lock!
+            deploying_web_process.lock!
+
+            deployment.update(
+              last_healthy_at: Time.now,
+              state: DeploymentModel::DEPLOYING_STATE,
+              status_value: DeploymentModel::ACTIVE_STATUS_VALUE,
+              status_reason: DeploymentModel::DEPLOYING_STATUS_REASON
+            )
+
+            if deploying_web_process.instances >= deployment.original_web_process_instance_count
+              Finalize.new(deployment).call
+              return
+            end
+
+            ScaleDownCanceledProcesses.new(deployment).call
+            ScaleDownOldProcess.new(deployment, oldest_web_process_with_instances, desired_old_instances).call
+
+            deploying_web_process.update(instances: desired_new_instances)
+          end
+        end
+
+        private
+
+        def desired_old_instances
+          [(oldest_web_process_with_instances.instances - deployment.max_in_flight), 0].max
+        end
+
+        def desired_new_instances
+          [deploying_web_process.instances + deployment.max_in_flight, deployment.original_web_process_instance_count].min
+        end
+
+        def oldest_web_process_with_instances
+          @oldest_web_process_with_instances ||= app.web_processes.select { |process| process.instances > 0 }.min_by { |p| [p.created_at, p.id] }
+        end
+
+        def deploying_web_process
+          @deploying_web_process ||= deployment.deploying_web_process
+        end
+
+        def all_instances_routable?
+          instances = instance_reporters.all_instances_for_app(deployment.deploying_web_process)
+          instances.all? { |_, val| val[:state] == VCAP::CloudController::Diego::LRP_RUNNING && val[:routable] }
+        rescue CloudController::Errors::ApiError # the instances_reporter re-raises InstancesUnavailable as ApiError
+          logger.info("skipping-deployment-update-for-#{deployment.guid}")
+          false
+        end
+
+        def instance_reporters
+          CloudController::DependencyLocator.instance.instances_reporters
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/scale_down_canceled_processes.rb

@@ -0,0 +1,30 @@
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class ScaleDownCanceledProcesses
+        attr_reader :deployment
+
+        def initialize(deployment)
+          @deployment = deployment
+        end
+
+        def call
+          superseded_processes.each { |p| p.lock!.update(instances: 0) }
+        end
+
+        private
+
+        def superseded_processes
+          # Find interim web processes that (a) belong to a SUPERSEDED (CANCELED) deployment and (b) have instances
+          # and scale them to zero.
+          deployment.app.web_processes_dataset.
+            qualify.
+            join(:deployments, deploying_web_process_guid: :guid).
+            where(deployments__state: DeploymentModel::CANCELED_STATE).
+            where(deployments__status_reason: DeploymentModel::SUPERSEDED_STATUS_REASON).
+            where(Sequel[:processes__instances] > 0)
+        end
+      end
+    end
+  end
+end

lib/cloud_controller/deployment_updater/actions/scale_down_old_process.rb

@@ -0,0 +1,35 @@
+module VCAP::CloudController
+  module DeploymentUpdater
+    module Actions
+      class ScaleDownOldProcess
+        attr_reader :deployment, :process, :app, :desired_instances
+
+        def initialize(deployment, process, desired_instances)
+          @deployment = deployment
+          @app = deployment.app
+          @process = process
+          @desired_instances = desired_instances
+        end
+
+        def call
+          if desired_instances == 0 && is_interim_process?(process)
+            process.destroy
+            return
+          end
+
+          process.update(instances: desired_instances)
+        end
+
+        private
+
+        def is_original_web_process?(process)
+          process == app.oldest_web_process
+        end
+
+        def is_interim_process?(process)
+          !is_original_web_process?(process)
+        end
+      end
+    end
+  end
+end