foreman_patch 1.1.1

data/app/lib/actions/foreman_patch/invocation/ensure_services.rb

@@ -0,0 +1,47 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class EnsureServices < Actions::EntryAction
+        include Actions::Helpers::WithFeatureAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(host)
+          action_subject(host)
+
+          sequence do
+            plan_feature_action('ensure_services', host)
+            plan_self
+          end
+        end
+
+        def run
+          if exit_status != 0
+            users = ::User.select { |user| user.receives?(:patch_invocation_failure) }.compact
+
+            begin
+              MailNotification[:patch_invocation_failure].deliver(users: users, host: host, output: live_output) unless users.blank?
+            rescue => error
+              message = _('Unable to send patch invocation failure: %{error}') % {error: error}
+              Rails.logger.error(message)
+            end
+
+            fail _('Ensure services failed')
+          end
+        end
+
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Skip
+        end
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+      end
+    end
+  end
+end
+

data/app/lib/actions/foreman_patch/invocation/patch.rb

@@ -0,0 +1,93 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class Patch < Actions::EntryAction
+        include ::Actions::Helpers::WithContinuousOutput
+
+        execution_plan_hooks.use :update_status, on: ::Dynflow::ExecutionPlan.states
+
+        def plan(invocation)
+          action_subject(invocation.host, invocation_id: invocation.id)
+
+          invocation.update!(task_id: task.id)
+
+          sequence do
+            plan_action(Actions::ForemanPatch::Invocation::Action, host, 'katello_package_update',
+                        pre_script: 'yum clean all; subscription-manager refresh',
+                        package: Setting[:skip_broken_patches] ? '--skip-broken' : nil)
+            plan_action(Actions::ForemanPatch::Invocation::Action, host, 'power_action',
+                        action: 'restart')
+            plan_action(Actions::ForemanPatch::Invocation::WaitForHost, host)
+            plan_action(Actions::ForemanPatch::Invocation::Action, host, 'ensure_services', false)
+            plan_self
+          end
+        end
+
+        def finalize
+          host.group_facet.last_patched_at = Time.current
+          host.group_facet.save!
+        end
+
+        def update_status(execution_plan)
+          return unless root_action?
+
+          case execution_plan.state
+          when 'scheduled', 'pending', 'planning', 'planned'
+            invocation.update!(status: 'pending')
+          when 'running'
+            invocation.update!(status: 'running')
+          else
+            action = failed_action
+            if action.nil?
+              invocation.update!(status: 'success')
+            else
+              invocation.update!(status: action.required? ? 'error' : 'warning')
+            end
+          end
+        end
+
+        def live_output
+          continuous_output.sort!
+          continuous_output.raw_outputs
+        end
+
+        def continuous_output_providers
+          planned_actions.select do |action|
+            action.respond_to?(:fill_continuous_output)
+          end
+        end
+
+        def rescue_strategy
+          planned_actions.each do |planned_action|
+            if planned_action.steps.compact.any? { |step| step.state == :error }
+              return rescue_strategy_for_planned_action(planned_action)
+            end
+          end
+          rescue_strategy_for_self
+        end
+
+        def rescue_strategy_for_self
+          ::Dynflow::Action::Rescue::Fail
+        end
+
+        private
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+        def invocation
+          @invocation ||= ::ForemanPatch::Invocation.find(input[:invocation_id])
+        end
+
+        def failed_action
+          planned_actions.find do |action|
+            action.steps.compact.any? { |step| [:error, :skipped].include? step.state }
+          end
+        end
+
+      end
+    end
+  end
+end
+          

data/app/lib/actions/foreman_patch/invocation/reschedule.rb

@@ -0,0 +1,21 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class Reschedule < Actions::EntryAction
+
+        def plan(invocation)
+          action_subject(invocation)
+          
+          round = invocation.cycle.rounds.find_by(group: invocation.host.group)
+
+          if round.nil?
+            invocation.destroy
+          else
+            invocation.update!(round: round)
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/invocation/restart.rb

@@ -0,0 +1,101 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class Restart < Actions::EntryAction
+        include Actions::Helpers::WithFeatureAction
+        include Dynflow::Action::Polling
+
+        def plan(host)
+          action_subject(host)
+
+          sequence do
+            plan_feature_action('power_action', host, action: 'restart')
+            plan_self
+          end
+        end
+
+        def done?
+          external_task[:status] == :running
+        end
+
+        def invoke_external_task
+          if exit_status != 0
+            send_failure_notification
+            fail(_('Restart command failed to execute'))
+          end
+
+          schedule_timeout(Setting[:host_max_wait_for_up]) if Setting[:host_max_wait_for_up]
+          
+          { status: :stopping }
+        end
+
+        def poll_external_task
+          socket = TCPSocket.new(host.ip, Setting[:remote_execution_ssh_port])
+          socket.close
+
+          if external_task[:status] == :stopping
+            log_poll_result(_('Server status: stopping'))
+            { status: :stopping }
+          else
+            log_poll_result(_('Server status: running'))
+            { status: :running }
+          end
+        rescue
+          log_poll_result(_('Server status: starting'))
+
+          { status: :starting }
+        end
+
+        def poll_intervals
+          case external_task[:status]
+          when :stopping
+            [1]
+          when :starting
+            [10]
+          else
+            super
+          end
+        end
+
+        def process_timeout
+          continuous_output.add_output(_('Server did not respond within alloted time after restart.'))
+
+          send_failure_notification
+
+          fail("Timeout exceeded.")
+        end
+
+        def log_poll_result(status)
+          results = delegated_output.fetch('result', [])
+
+          results << {
+            'output_type' => 'debug',
+            'output' => status,
+            'timestamp' => Time.now.getlocal
+          }
+        end
+
+        def send_failure_notification
+          users = ::User.select { |user| user.receives?(:patch_invocation_failure) }.compact
+
+          begin
+            MailNotification[:patch_invocation_failure].deliver(user: users, host: host, output: live_output) unless users.blank?
+          rescue => error
+            message = _('Unable to send patch invocation failure: %{error}') % {error: error}
+            Rails.logger.error(message)
+          end
+        end
+
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Fail
+        end
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+      end
+    end
+  end
+end
+

data/app/lib/actions/foreman_patch/invocation/update_packages.rb

@@ -0,0 +1,52 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class UpdatePackages < Actions::EntryAction
+        include Actions::Helpers::WithFeatureAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(host)
+          action_subject(host)
+
+          sequence do
+            plan_feature_action('katello_package_update', host, 
+                                pre_script: 'yum clean all; subscription-manager refresh',
+                                package: Setting[:skip_broken_patches] ? '--skip-broken' : nil)
+            plan_self
+          end
+        end
+
+        def run
+          if exit_status != 0
+            users = ::User.select { |user| user.receives?(:patch_invocation_failure) }.compact
+
+            begin
+              MailNotification[:patch_invocation_failure].deliver(users: users, host: host, output: live_output) unless users.blank?
+            rescue => error
+              message = _('Unable to send patch invocation failure: %{error}') % {error: error}
+              Rails.logger.error(message)
+            end
+
+            fail _('Package update failed')
+          else
+            host.group_facet.last_patched_at = Time.current
+            host.group_facet.save!
+          end
+        end
+
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Fail
+        end
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+      end
+    end
+  end
+end
+

data/app/lib/actions/foreman_patch/invocation/wait_for_host.rb

@@ -0,0 +1,103 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class WaitForHost < Actions::EntryAction
+        include Actions::Helpers::WithContinuousOutput
+        include Actions::Helpers::FailureNotification
+        include Dynflow::Action::Polling
+
+        def plan(host)
+          action_subject(host)
+
+          plan_self
+        end
+
+        def done?
+          external_task[:status] == 'available'
+        end
+
+        def invoke_external_task
+          schedule_timeout(Setting[:host_max_wait_for_up]) if Setting[:host_max_wait_for_up]
+
+          { status: 'waiting' }
+        end
+
+        def poll_external_task
+          socket = TCPSocket.new(host.ip, Setting[:remote_execution_ssh_port])
+          
+          status = starting? ? 'available' : 'waiting'
+          
+          { status: status }
+        rescue
+          status = 'starting'
+
+          { status: status }
+        ensure
+          socket.close if socket
+          add_output("Poll result: #{status}")
+        end
+
+        def poll_intervals
+          case external_task[:status]
+          when 'waiting'
+            [10, 1]
+          when 'starting'
+            [10]
+          else
+            super
+          end
+        end
+
+        def on_finish
+          add_output(_('Host is up'), 'stdout')
+        end
+
+        def process_timeout
+          add_output(_('Server did not respond withing alloted time after restart.'), 'stderr')
+          send_failure_notification
+          fail('Timeout exceeded.')
+        end
+
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Fail
+        end
+
+        def live_output
+          continuous_output.sort!
+          continuous_output.raw_outputs
+        end
+
+        def continuous_output_providers
+          super << self
+        end
+
+        def fill_continuous_output(continuous_output)
+          output.fetch('result', []).each do |raw_output|
+            continuous_output.add_raw_output(raw_output)
+          end
+        end
+
+        private
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+        def starting?
+          external_task[:status] == 'starting'
+        end
+
+        def add_output(message, type = 'debug', timestamp = Time.now.getlocal)
+          formatted_output = {
+            output_type: type,
+            output: message,
+            timestamp: timestamp.to_f
+          }
+
+          output[:result] = [] if output[:result].nil?
+          output[:result] << formatted_output
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/round/add_missing_hosts.rb

@@ -0,0 +1,21 @@
+module Actions
+  module ForemanPatch
+    module Round
+      class AddMissingHosts < Actions::EntryAction
+
+        def plan(round, *hosts)
+          hosts = hosts.flatten
+          action_subject(round, hosts: hosts.map(&:to_action_input))
+
+          # Don't add already run hosts
+          hosts -= round.cycle.hosts
+
+          round.group.hosts.where(id: hosts).each do |host|
+            round.invocations.find_or_create_by!(host_id: host.id)
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/round/create.rb

@@ -0,0 +1,37 @@
+module Actions
+  module ForemanPatch
+    module Round
+      class Create < Actions::EntryAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(group, window)
+          action_subject(group, window)
+
+          round = window.rounds.create!({
+            group: group,
+            name: group.name,
+            description: group.description,
+            priority: group.priority,
+            max_unavailable: group.max_unavailable,
+          })
+
+          plan_self(round: round.to_action_input)
+          plan_action(Actions::ForemanPatch::Round::ResolveHosts, round)
+        end
+
+        def run
+          output[:round] = round.to_action_input
+        end
+
+        def round
+          @round = ::ForemanPatch::Round.find(input[:round][:id])
+        end
+
+      end
+    end
+  end
+end
+

data/app/lib/actions/foreman_patch/round/patch.rb

@@ -0,0 +1,81 @@
+module Actions
+  module ForemanPatch
+    module Round
+      class Patch < Actions::ActionWithSubPlans
+        include Dynflow::Action::WithBulkSubPlans
+
+        def plan(round)
+          action_subject(round)
+
+          limit_concurrency_level round.max_unavailable unless round.max_unavailable.nil?
+
+          plan_self
+
+          round.update!(status: 'pending')
+        end
+
+        def create_sub_plans
+          current_batch.map do |invocation|
+            trigger(Actions::ForemanPatch::Invocation::Patch, invocation)
+          end
+        end
+
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Skip
+        end
+
+        def run(event = nil)
+          super unless event == Dynflow::Action::Skip
+        end
+
+        def initiate
+          round.update!(status: 'running')
+
+          users = ::User.select { |user| user.receives?(:patch_group_initiated) }.compact
+
+          begin
+            MailNotification[:patch_group_initiated].deliver(users: users, group: round) unless users.blank?
+          rescue => error
+            Rails.logger.error(error)
+          end
+
+          super
+        end
+
+        def check_for_errors!
+        end
+
+        def on_finish
+          round.update!(status: 'complete')
+
+          users = ::User.select { |user| user.receives?(:patch_group_completed) }.compact
+
+          MailNotification[:patch_group_completed].deliver(users: users, group: round) unless users.blank?
+        rescue => error
+          Rails.logger.error(error)
+        end
+
+        def round
+          @round ||= ::ForemanPatch::Round.find(input[:round][:id])
+        end
+
+        def invocations
+          round.invocations.order(:id)
+        end
+
+        def batch(from, size)
+          invocations.offset(from).limit(size)
+        end
+
+        def total_count
+          output[:total_count] || invocations.count
+        end
+
+        def humanized_name
+          'Patch Group: %s' % round.name
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/round/plan.rb

@@ -0,0 +1,33 @@
+module Actions
+  module ForemanPatch
+    module Round
+      class Plan < Actions::EntryAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(group, window)
+          action_subject(group, window: window)
+
+          action = plan_action(::Actions::ForemanPatch::Round::Create, params(group, window))
+          plan_action(::Actions::ForemanPatch::Round::ResolveHosts, action.output[:round])
+        end
+
+        private
+
+        def params(group, window)
+          {
+            window: window,
+            group: group.to_action_input,
+            name: group.name,
+            description: group.description,
+            priority: group.priority,
+            max_unavailable: group.max_unavailable,
+          }
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/round/resolve_hosts.rb

@@ -0,0 +1,45 @@
+module Actions
+  module ForemanPatch
+    module Round
+      class ResolveHosts < Actions::EntryAction
+
+        def plan(round)
+          input.update serialize_args(round: round)
+          plan_self
+        end
+
+        def run
+          output[:invocations] = {
+            added: add_missing_hosts,
+            removed: remove_non_group_hosts,
+          }
+        end
+
+        private
+
+        def add_missing_hosts
+          return [] if round.group.nil?
+
+          round.group.hosts.map do |host|
+            round.invocations.find_or_create_by!(host_id: host.id).to_action_input
+          end
+        end
+
+        def remove_non_group_hosts
+          return [] if round.group.nil?
+
+          invocations = round.invocations.where.not(host_id: round.group.host_ids).destroy_all
+
+          invocations.map do |invocation|
+            invocation.to_action_input
+          end
+        end
+
+        def round
+          @round ||= ::ForemanPatch::Round.find(input[:round][:id])
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_patch/window/create.rb

@@ -0,0 +1,41 @@
+module Actions
+  module ForemanPatch
+    module Window
+      class Create < Actions::EntryAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(window_plan, cycle)
+          action_subject(window_plan, cycle)
+
+          window = cycle.windows.create!(window_plan.to_params)
+
+          sequence do
+            concurrence do
+              window_plan.groups.each do |group|
+                plan_action(Actions::ForemanPatch::Round::Create, group, window)
+              end
+            end
+
+            plan_action(Actions::ForemanPatch::Window::Publish, window)
+          end
+
+          plan_self(window: window.to_action_input)
+        end
+
+        def run
+          output.update(window: window.to_action_input)
+        end
+
+        def window
+          @window = ::ForemanPatch::Window.find(input[:window][:id])
+        end
+
+        private
+
+      end
+    end
+  end
+end