process_observer.rb

module VCAP::CloudController
  module ProcessObserver
    class << self
      extend Forwardable

      def configure(stagers, runners)
        @stagers = stagers
        @runners = runners
      end

      def deleted(process)
        with_diego_communication_handling do
          @runners.runner_for_process(process).stop
        end
      end

      def updated(process)
        changes = process.previous_changes
        return unless changes

        with_diego_communication_handling do
          if changes.key?(:state) || changes.key?(:diego) || changes.key?(:enable_ssh) || changes.key?(:ports)
            react_to_state_change(process)
          elsif changes.key?(:instances)
            react_to_instances_change(process)
          end
        end
      end

      private

      def react_to_state_change(process)
        unless process.started?
          @runners.runner_for_process(process).stop
          return
        end

        process.update(revision: process.app.latest_revision) if process.revisions_enabled?

        # Reload to get the DB-assigned updated_at, which ProcessesSync compares against
        # the LRP annotation to detect drift. Without this, the stale in-memory value
        # causes an unnecessary re-sync.
        @runners.runner_for_process(process.reload).start unless process.needs_staging?
      end

      def react_to_instances_change(process)
        # Same as above: reload to get the DB-assigned updated_at before building the LRP annotation.
        @runners.runner_for_process(process.reload).scale if process.started? && process.active?
      end

      def with_diego_communication_handling
        yield
      rescue Diego::Runner::CannotCommunicateWithDiegoError => e
        logger.error("Failed communicating with diego backend: #{e.message}. Continuing, sync job should eventually re-sync any desired changes to diego.")
      end

      def logger
        @logger ||= Steno.logger('cc.process_observer')
      end
    end
  end
end