foreman_patch 1.1.1

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

@@ -0,0 +1,72 @@
+module Actions
+  module ForemanPatch
+    module Window
+      class Patch < Actions::EntryAction
+        execution_plan_hooks.use :update_window_status, on: ::Dynflow::ExecutionPlan.states
+
+        def resource_locks
+          :link
+        end
+
+        def delay(delay_options, window)
+          window.task_id = task.id
+          window.save!
+
+          action_subject(window)
+
+          super delay_options, window
+        end
+
+        def plan(window)
+          window.task_id = task.id
+          window.save!
+
+          action_subject(window)
+
+          sequence do
+            window.rounds.group_by(&:priority).each do |_, groups|
+              concurrence do
+                groups.each do |group|
+                  plan_action(Actions::ForemanPatch::Round::Patch, group)
+                end
+              end
+            end
+          end
+          plan_self
+        end
+
+        def window
+          @window ||= ::ForemanPatch::Window.find(input[:window][:id])
+        end
+
+        def rescue_strategy_for_self
+          ::Dynflow::Action::Rescue::Fail
+        end
+
+        def humanized_name
+          if input and input[:window][:name]
+            _('Run Patch Window: %{window}' % {window: input[:window][:name]})
+          else
+            _('Run Patch Window')
+          end
+        end
+
+        def update_window_status(execution_plan)
+          return unless root_action?
+
+          case execution_plan.state
+          when 'scheduled'
+            window.status = execution_plan.state
+          when 'pending','planning','planned','running'
+            window.status = 'running'
+          when 'stopped'
+            window.status = 'completed'
+          else
+            window.status = execution_plan.state
+          end
+          window.save!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Actions
+  module ForemanPatch
+    module Window
+      class Plan < Actions::EntryAction
+
+        def plan(window_plan, cycle)
+          input.update serialize_args(window_plan: window_plan, cycle: cycle)
+
+          sequence do
+            action = plan_action(::Actions::ForemanPatch::Window::Create, params(window_plan, cycle))
+
+            concurrence do
+              window_plan.groups.each do |group|
+                plan_action(::Actions::ForemanPatch::Round::Plan, group, action.output[:window])
+              end
+            end
+
+            plan_action(::Actions::ForemanPatch::Window::Publish, action.output[:window])
+          end
+        end
+
+        def humanized_name
+          _('Plan window: %s') % input[:window_plan][:name]
+        end
+
+        private
+
+        def params(window_plan, cycle)
+          {
+            cycle: cycle,
+            name: window_plan.name,
+            description: window_plan.description,
+            start_at: window_plan.start_at.to_s,
+            end_by: window_plan.end_by.to_s,
+          }
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,32 @@
+module Actions
+  module ForemanPatch
+    module Window
+      class Publish < Actions::EntryAction
+
+        def plan(window)
+          input.update serialize_args(window: window)
+          plan_self
+        end
+
+        def run
+          ticket = window.ticket
+
+          input.update(payload: ticket.payload.raw.compact)
+
+          ticket.save
+
+          output.update(response: ticket.response)
+        end
+
+        def window
+          @window ||= ::ForemanPatch::Window.find(input[:window][:id])
+        end
+
+        def humanized_name
+          _('Publish ticket for %s') % window.name
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Actions
+  module ForemanPatch
+    module Window
+      class ResolveHosts < Actions::EntryAction
+
+        def plan(window)
+          input.update serialize_args(window: window)
+
+          sequence do
+            concurrence do
+              window.rounds.each do |round|
+                plan_action(Actions::ForemanPatch::Round::ResolveHosts, round)
+              end
+            end
+
+            plan_action(Actions::ForemanPatch::Window::Publish, window)
+          end
+        end
+
+        def window
+          @window ||= ::ForemanPatch::Window.find(input[:window][:id])
+        end
+
+        def humanized_name
+          _('Resolve Hosts for %s') % window.name
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/helpers/failure_notification.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Helpers
+    module FailureNotification
+
+      def send_failure_notification
+        users = ::User.select { |user| user.receives?(:patch_invocation_failure) }.compact
+
+        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
+
+    end
+  end
+end

data/app/lib/actions/helpers/with_feature_action.rb

@@ -0,0 +1,102 @@
+module Actions
+  module Helpers
+    module WithFeatureAction
+      include ::Actions::Helpers::WithDelegatedAction
+
+      class TemplateInvocationInputValue
+        attr_reader :template_invocation, :template_input, :value
+
+        def initialize(invocation, input, value)
+          @template_invocation = invocation
+          @template_input = input
+          @value = value
+        end
+      end
+
+      class TemplateInvocation
+        attr_reader :template, :input_values
+
+        def initialize(template, **input_values)
+          @template = template
+
+          @input_values = template.template_inputs_with_foreign.map do |template_input|
+            TemplateInvocationInputValue.new(self, template_input, input_values[template_input.name.intern])
+          end
+        end
+
+        def effective_user
+          if template.provider.supports_effective_user?
+            Setting[:remote_execution_effective_user]
+          else
+            nil
+          end
+        end
+
+      end
+
+      def plan_feature_action(feature_name, host, **input_values)
+        input['feature_name'] = feature_name
+
+        invocation = TemplateInvocation.new(template, **input_values)
+
+        provider = template.provider
+        proxy_selector = provider.required_proxy_selector_for(template) || ::RemoteExecutionProxySelector.new
+
+        proxy = proxy_selector.determine_proxy(host, template.provider_type.to_s)
+
+        renderer = InputTemplateRenderer.new(template, host, invocation)
+        script = renderer.render
+        raise _('Failed rendering template: %s') % renderer.error_message unless script
+
+        additional_options = {
+          hostname: provider.find_ip_or_hostname(host),
+          execution_timeout_interval: template.execution_timeout_interval,
+          script: script,
+          secrets: provider.secrets(host),
+        }
+        action_options = provider.proxy_command_options(invocation, host).merge(additional_options)
+
+        plan_delegated_action(proxy, provider.proxy_action_class, action_options)
+      end
+
+      def exit_status
+        delegated_output[:exit_status]
+      end
+
+      def feature
+        @feature ||= ::RemoteExecutionFeature.feature(input['feature_name'])
+      end
+
+      def template
+        @template ||= feature.job_template
+      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)
+        delegated_output.fetch('result', []).each do |raw_output|
+          continuous_output.add_raw_output(raw_output)
+        end
+
+        final_timestamp = (continuous_output.last_timestamp || task.ended_at).to_f + 1
+
+        continuous_output.add_output(_('Exit status: %s') % exit_status, 'stdout', final_timestamp) if exit_status
+      end
+
+      def feature_action
+        delegated_action
+      end
+
+    end
+  end
+end
+
+
+

data/app/lib/actions/middleware/check_exit_status.rb

@@ -0,0 +1,31 @@
+module Actions
+  module Middleware
+    class CheckExitStatus < Dynflow::Middleware
+
+      def run(*args)
+        pass(*args)
+
+        if action.exit_status != 0
+          send_failure_notification
+
+          raise "Non-zero exit status"
+        end
+      end
+
+      private
+
+      def send_failure_notification
+        users = ::Users.select { |user| user.receives?(:patch_invocation_failure) }.compact
+
+        begin
+          MailNotification[:patch_invocation_failure].deliver(users: users,
+                                                              host: action.host,
+                                                              output: action.live_output) unless users.blank?
+        rescue => error
+          message = _('Unable to send patch invocation failure: %{error}') % { error: error }
+          Rails.logger.error(message)
+        end
+      end
+    end
+  end
+end

data/app/mailers/foreman_patch/cycle_mailer.rb

@@ -0,0 +1,17 @@
+module ForemanPatch
+  class CycleMailer < ApplicationMailer
+    helper ForemanPatch::TicketHelper
+
+    def planned(options)
+      @user = options[:user]
+
+      @cycle = options[:cycle]
+
+      set_locale_for(@user) do
+        mail(to: @user.mail, subject: (_("Patching Cycle Planned")))
+      end
+    end
+
+  end
+end
+

data/app/mailers/foreman_patch/group_mailer.rb

@@ -0,0 +1,41 @@
+module ForemanPatch
+  class GroupMailer < ApplicationMailer
+
+    def initiated(options)
+      user = options[:user]
+
+      @group = options[:group].name
+      @hosts = options[:group].invocations.pluck(:name)
+
+      set_locale_for(user) do
+        mail(to: user.mail, subject: (_("%s Patching Initiated") % @group))
+      end
+    end
+
+    def completed(options)
+      user = options[:user]
+
+      @group = options[:group].name
+      @total = options[:group].invocations.count
+      @successes = options[:group].invocations.successful.pluck(:name)
+      @warnings = options[:group].invocations.warning.pluck(:name)
+      @failures = options[:group].invocations.failed.pluck(:name)
+
+      set_locale_for(user) do
+        mail(to: user.mail, subject: (_("%s Patching Completed") % @group))
+      end
+    end
+
+    def report(options)
+      user = options[:user]
+
+      @group = options[:group].name
+      @result = options[:result]
+
+      set_locale_for(user) do
+        mail(to: user.mail, subject: (_("%s Preliminary Report") % @group))
+      end
+    end
+  end
+end
+

data/app/mailers/foreman_patch/invocation_mailer.rb

@@ -0,0 +1,19 @@
+module ForemanPatch
+  class InvocationMailer < ApplicationMailer
+    add_template_helper JobInvocationOutputHelper
+    add_template_helper RemoteExecutionHelper
+
+    def failure(options)
+      user = options[:user]
+
+      @host = options[:host]
+      @output = options[:output]
+      @line_counter = 0
+
+      set_locale_for(user) do
+        mail(to: user.mail, subject: (_("Patching Failure for %s") % @host.name))
+      end
+    end
+  end
+end
+

data/app/models/foreman_patch/concerns/group_facet_host_extensions.rb

@@ -0,0 +1,35 @@
+module ForemanPatch
+  module Concerns
+    module GroupFacetHostExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :group, through: :group_facet
+
+        scoped_search relation: :group, on: :name, complete_value: true, rename: :patch_group
+        scoped_search relation: :group_facet, on: :last_patched_at, complete_value: true, rename: :last_patched
+
+        accepts_nested_attributes_for(
+          :group_facet,
+          self.nested_attributes_options[:group_facet].merge(
+            reject_if: :group_facet_ignore_update?
+          )
+        )
+
+        def group_facet_ignore_update?(attributes)
+          self.group_facet.blank? && (
+            attributes.values.all?(&:blank?) ||
+            attributes['group_id'].blank?
+          )
+        end
+      end
+
+      module ClassMethods
+      end
+    end
+  end
+end
+
+class ::Host::Managed::Jail < Safemode::Jail
+  allow :group
+end

data/app/models/foreman_patch/concerns/host_managed_extensions.rb

@@ -0,0 +1,17 @@
+module ForemanPatch
+  module Concerns
+    module HostManagedExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :invocations, -> { unscope(:order) }, class_name: 'ForemanPatch::Invocation', foreign_key: :host_id, dependent: :delete_all
+        has_many :rounds, class_name: 'ForemanPatch::Round', through: :invocations
+        has_many :windows, class_name: 'ForemanPatch::Window', through: :rounds
+
+        scoped_search relation: :rounds, on: :id, complete_value: false, rename: :patch_round_id
+      end
+
+    end
+  end
+end
+

data/app/models/foreman_patch/cycle.rb

@@ -0,0 +1,49 @@
+module ForemanPatch
+  class Cycle < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    belongs_to :plan, class_name: 'ForemanPatch::Plan'
+
+    has_many :windows, -> { order(start_at: :asc) }, class_name: 'ForemanPatch::Window', foreign_key: :cycle_id, inverse_of: :cycle, dependent: :delete_all
+    has_many :rounds, through: :windows
+    has_many :tasks, through: :windows
+    has_many :hosts, through: :windows
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :start_date, complete_value: false
+    scoped_search on: :end_date, complete_value: false
+    scoped_search on: :plan_id, complete_value: false
+    scoped_search relation: :plan, on: :name, complete_value: true, rename: :plan
+
+    validates :name, presence: true
+    validates :start_date, presence: true
+    validates :end_date, presence: true
+
+    scope :planned, -> { where('start_date > ?', Date.current) }
+    scope :active, -> { where('end_date >= ?', Date.current) }
+    scope :running, -> { where('? BETWEEN start_date AND end_date', Date.current) }
+    scope :completed, -> { where('end_date < ?', Date.current) }
+
+    def planned?
+      start_date > Date.current
+    end
+
+    def active?
+      end_date >= Date.current
+    end
+
+    def running?
+      start_date <= Date.current and end_date >= Date.current
+    end
+
+    def completed?
+      end_date < Date.current
+    end
+
+    class Jail < ::Safemode::Jail
+      allow :id, :name, :description, :start_date, :end_date, :windows
+    end
+
+  end
+end
+

data/app/models/foreman_patch/group.rb

@@ -0,0 +1,43 @@
+module ForemanPatch
+  class Group < ::ApplicationRecord
+    include Katello::Ext::LabelFromName
+    include ForemanTasks::Concerns::ActionSubject
+    extend FriendlyId
+    friendly_id :label
+
+    include Authorizable
+
+    belongs_to :default_window_plan, class_name: 'ForemanPatch::WindowPlan'
+
+    has_many :group_facets, class_name: 'ForemanPatch::Host::GroupFacet', foreign_key: :group_id, inverse_of: :group, dependent: :nullify
+    has_many :hosts, through: :group_facets
+
+    has_many :rounds, class_name: 'ForemanPatch::Round', foreign_key: :group_id, dependent: :nullify
+
+    validates_lengths_from_database except: [:label]
+    validates :name, presence: true, uniqueness: true
+    validates :label, uniqueness: true,
+      presence: true
+
+    validates_with Katello::Validators::KatelloNameFormatValidator, attributes: :name
+    validates_with Katello::Validators::KatelloLabelFormatValidator, attributes: :label
+
+    scoped_search on: :id, complete_value: false
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :label, complete_value: true
+    scoped_search on: :default_window_plan_id, complete_value: true, rename: :default_window_id
+    scoped_search on: :priority, complete_value: true
+
+    scoped_search relation: :default_window_plan, on: :name, complete_value: true, rename: :default_window
+
+    def hosts_count
+      hosts.count
+    end
+
+    class Jail < Safemode::Jail
+      allow :id, :name, :label, :default_window_plan, :hosts
+    end
+
+  end
+end
+

data/app/models/foreman_patch/host/group_facet.rb

@@ -0,0 +1,13 @@
+module ForemanPatch
+  module Host
+    class GroupFacet < ::ApplicationRecord
+      self.table_name = 'foreman_patch_group_facets'
+      include Facets::Base
+
+      belongs_to :group, class_name: '::ForemanPatch::Group', inverse_of: :group_facets
+
+      validates :host, presence: true, allow_blank: false
+    end
+  end
+end
+

data/app/models/foreman_patch/invocation.rb

@@ -0,0 +1,60 @@
+module ForemanPatch
+  class Invocation < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    belongs_to :round, class_name: 'ForemanPatch::Round', inverse_of: :invocations
+    has_one :window, through: :round
+    has_one :cycle, through: :window
+
+    belongs_to :host, class_name: 'Host::Managed'
+
+    belongs_to :task, class_name: 'ForemanTasks::Task'
+
+    scope :planned, -> { where(status: 'planned') }
+    scope :pending, -> { where(status: 'pending') }
+    scope :running, -> { where(status: 'running') }
+    scope :successful, -> { where(status: 'success') }
+    scope :warning, -> { where(status: 'warning') }
+    scope :failed, -> { where(status: 'error') }
+    scope :cancelled, -> { where(status: 'cancelled') }
+    scope :completed, -> { where(status: ['success', 'warning', 'error', 'cancelled']) }
+
+    scope :in_windows, -> (*args) { joins(:window).where(foreman_patch_windows: { id: args.flatten }) }
+
+    scoped_search on: :status, complete_value: true
+    scoped_search relation: :host, on: :name, complete_value: true
+
+    default_scope { includes(:host).order('hosts.name') }
+
+    def phases
+      task&.main_action&.planned_actions || []
+    end
+
+    def complete?
+      ['success', 'warning', 'failed', 'cancelled'].include? status
+    end
+
+    def warning?
+      status == 'warning'
+    end
+
+    def failed?
+      status == 'error'
+    end
+
+    def success?
+      status == 'success'
+    end
+
+    def to_action_input
+      {
+        id: id,
+        name: host.name
+      }
+    end
+
+    class Jail < ::Safemode::Jail
+      allow :id, :host, :status
+    end
+  end
+end