foreman_patch 1.1.6.alpha4 → 1.2.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a0c418f7823f9284b25ba359c284ac4eb6f090e1826b32759ff11c4c9930a20
-  data.tar.gz: 52f7f32b37f8ab528b6946d17023ed613cf874ba913efc8b42b3c38dc13974bb
+  metadata.gz: 900b05514ac7bb3e7cec9d95b0ad2b982feea0081dd73be23ab17041cb44c95d
+  data.tar.gz: ebdd75375aaf6acebd342f0f00e7be6658ec5399c9172f84b50263fe2b22573a
 SHA512:
-  metadata.gz: fcddad96ea62cb31521ca728b418fc2f33fbbc9a167d06270fc4a8d45a5bb6d23915b9686af28c86203d9c4fdd48e62f2c8cf3afdb8c1695da49c8818df89cbb
-  data.tar.gz: 81d7bf80181451853b12c593cfac3bca9e662da2db237e7f54ce780a3b1a41e03a112a34b4fc81ad7bf5cd54096c85d22f7bbfa72b7c602603ca120f910ceb97
+  metadata.gz: d01c259cd2d57f7e4febcac38b3d9161c5ae3bd9fa84df2ef3f8cb9443a79350b7f6cc007c47aab787478f5516a70661fdae4777e13e95f8e4f25b459da0b449
+  data.tar.gz: 78a7fd36dd08a76f613bbf839ebbff94d5e7e7d31766276ff3f1a4b42f4a2555a316cbf377a8ec6e63610914f51f37447f5b7446b987c29efb310a7fffc5dd7a

data/app/controllers/foreman_patch/api/v2/invocations_controller.rb

@@ -23,6 +23,7 @@ module ForemanPatch
         api :GET, '/invocations/:id', N_('Get details of an invocation')
         param :id, :identifier, required: true
         def show
+          @invocation = ForemanPatch::Invocation.find(params[:id])
         end
 
         api :PUT, '/invocations/:id', N_('Move the invocation to another round')
@@ -34,29 +35,6 @@ module ForemanPatch
           process_response @invocation.update(invocation_params)
         end
 
-        api :PUT, '/invocations/move', N_('Move invocations to another round')
-        param :ids, Array, required: true, desc: N_('List of invocation ids')
-        param :round_id, Integer, required: true, desc: N_('Id of the destination round')
-        def move
-          @invocations = ForemanPatch::Invocation.where(id: params[:ids])
-
-          @errors = []
-          @invocations.each do |invocation|
-            round = invocation.round.cycle.rounds.find(params[:round_id])
-            invocation.update(round: round)
-          rescue
-          end
-
-          @invocations = ForemanPatch::Invocation.where(id: params[:ids], round_id: params[:round_id])
-        end
-
-        api :PUT, '/invocations/cancel', N_('Cancel invocations')
-        param :ids, Array, required: true, desc: N_('List of invocation ids')
-        def cancel
-          @invocations = ForemanPatch::Invocation.where(id: params[:ids])
-          @invocations.update_all(status: 'cancelled')          
-        end
-
         api :DELETE, 'invocations/:id', N_('Delete the patch invocation')
         param :id, :identifier, required: true
         def destroy

data/app/controllers/foreman_patch/concerns/hosts_controller_extensions.rb

@@ -3,52 +3,58 @@ module ForemanPatch
     module HostsControllerExtensions
       extend ActiveSupport::Concern
 
-      MULTIPLE_EDIT_ACTIONS = %w[select_multiple_patch_group, update_multiple_patch_group].freeze
+      module Overrides
+        def action_permission
+          case params[:action]
+          when 'select_multiple_patch_group', 'update_multiple_patch_group'
+            :edit
+          else
+            super
+          end
+        end
+      end
 
       included do
-        before_action :find_multiple_for_foreman_patch_extensions, only: MULTIPLE_EDIT_ACTIONS
-        after_action :reschedule_patching, only: :update
+        prepend Overrides
 
-        define_action_permission MULTIPLE_EDIT_ACTIONS, :edit
-
-        helper ForemanPatch::HostsHelper
-      end
-
-      def select_multiple_patch_group
-      end
+        after_action :reschedule_patching, only: :update
 
-      def update_multiple_patch_group
-        if (params['patch_group']['id'].blank?)
-          @hosts.each do |host|
-            group_facet = host.group_facet
-            group_facet.group = nil unless group_facet.blank?
-            host.save!
-          end
-        else
-          patch_group = ForemanPatch::Group.find(params['patch_group']['id'])
+        def select_multiple_patch_group
+          find_multiple
+        end
 
-          @hosts.each do |host|
-            group_facet = host.group_facet || host.build_group_facet
-            group_facet.group = patch_group
-            host.save!
+        def update_multiple_patch_group
+          find_multiple
+
+          if (params['patch_group']['id'].blank?)
+            @hosts.each do |host|
+              group_facet = host.group_facet
+              group_facet.group = nil unless group_facet.blank?
+              host.save!
+            end
+          else
+            patch_group = ForemanPatch::Group.find(params['patch_group']['id'])
+
+            @hosts.each do |host|
+              group_facet = host.group_facet || host.build_group_facet
+              group_facet.group = patch_group
+              host.save!
+            end
           end
-        end
 
-        ForemanTasks.async_task(Actions::ForemanPatch::Host::Reschedule, @hosts, include_active: params['patch_group']['include_active'])
+          ForemanTasks.async_task(Actions::ForemanPatch::Host::Reschedule, @hosts, include_active: params['patch_group']['include_active'])
 
-        success _('Updated hosts: changed patch group')
-        redirect_back_or_to hosts_path
-      end
+          success _('Updated hosts: changed patch group')
+          redirect_back_or_to hosts_path
+        end
 
-      def reschedule_patching
-        return if @host.group_facet.nil?
-        return unless @host.group_facet.saved_change_to_attribute?(:group_id)
+        def reschedule_patching
+          return if @host.group_facet.nil?
+          return unless @host.group_facet.saved_change_to_attribute?(:group_id)
 
-        ForemanTasks.async_task(Actions::ForemanPatch::Host::Reschedule, @host)
-      end
+          ForemanTasks.async_task(Actions::ForemanPatch::Host::Reschedule, @host)
+        end
 
-      def find_multiple_for_foreman_patch_extensions
-        find_multiple
       end
     end
   end

data/app/lib/actions/foreman_patch/cycle/complete.rb

@@ -0,0 +1,41 @@
+module Actions
+  module ForemanPatch
+    module Cycle
+      class Complete < Actions::EntryAction
+
+        def delay(delay_options, cycle)
+          action_subject(cycle)
+
+          super delay_options, cycle
+        end
+
+        def plan(cycle)
+          action_subject(cycle)
+          
+          plan_self
+        end
+
+        def finalize
+          users = ::User.select { |user| user.receives?(:patch_cycle_completed) }.compact
+
+          begin
+            MailNotification[:patch_cycle_completed].deliver(users: users, cycle: cycle) unless users.blank?
+          rescue => error
+            Rails.logger.error(error)
+          end
+        end
+
+        def humanized_name
+          _('Complete Patch Cycle: %s') % input[:cycle][:name]
+        end
+
+        private
+
+        def cycle
+          @cycle ||= ::ForemanPatch::Cycle.find(input[:cycle][:id])
+        end
+
+      end
+    end
+  end
+end

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

@@ -49,11 +49,7 @@ module Actions
         end
 
         def humanized_name
-          _('Create cycle:')
-        end
-
-        def humanized_input
-        input.dig(:plan, :name)
+          _('Create cycle: %s') % input[:plan][:name]
         end
 
         private

data/app/lib/actions/foreman_patch/cycle/initiate.rb

@@ -40,11 +40,7 @@ module Actions
         end
 
         def humanized_name
-          _('Initiating patch cycle:')
-        end
-
-        def humanized_input
-          cycle.name
+          _('Initiating patch cycle: %s') % cycle.name
         end
 
         def cycle

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

@@ -0,0 +1,66 @@
+module Actions
+  module ForemanPatch
+    module Cycle
+      class Plan < Actions::EntryAction
+
+        def delay(delay_options, plan)
+          input.update serialize_args(plan: plan)
+          add_missing_task_group(plan)
+
+          super delay_options, plan
+        end
+
+        def plan(plan)
+          input.update serialize_args(plan: plan)
+          add_missing_task_group(plan)
+
+          sequence do
+            plan_action(::Actions::ForemanPatch::Cycle::Create, plan)
+            plan_self
+          end
+        end
+
+        def run
+          cycle_plan.start_date = cycle_plan.next_cycle_start
+          cycle_plan.save!
+        end
+
+        def finalize
+          cycle_plan.iterate if cycle_plan.active_count > 0
+        end
+
+        def humanized_name
+          _('Plan cycle: %s') % input[:plan][:name]
+        end
+
+        private
+
+        def cycle_plan
+          @cycle_plan ||= ::ForemanPatch::Plan.find(input[:plan][:id])
+        end
+
+        def cycle
+          @cycle ||= ::ForemanPatch::Cycle.find(input[:cycle][:id])
+        end
+
+        def params(plan)
+          {
+            plan_id: plan.id,
+            name: ::ForemanPatch::CycleNameGenerator.generate(plan),
+            start_date: plan.start_date.to_s,
+            end_date: (plan.next_cycle_start - 1.day).to_s,
+          }
+        end
+
+        def add_missing_task_group(plan)
+          if plan.task_group.nil?
+            plan.task_group = ::ForemanPatch::PlanTaskGroup.create!
+            plan.save!
+          end
+          task.add_missing_task_groups(plan.task_group)
+        end
+
+      end
+    end
+  end
+end

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

@@ -46,7 +46,7 @@ module Actions
           provider = template.provider
           proxy_selector = provider.required_proxy_selector_for(template) || ::RemoteExecutionProxySelector.new
 
-          proxy = determine_proxy!(proxy_selector, template.provider_type.to_s, host)
+          proxy = proxy_selector.determine_proxy(host, template.provider_type.to_s)
 
           renderer = InputTemplateRenderer.new(template, host, invocation)
           script = renderer.render
@@ -61,7 +61,7 @@ module Actions
           action_options = provider.proxy_command_options(invocation, host).merge(additional_options)
 
           sequence do
-            plan_action(::Actions::ForemanPatch::Invocation::ProxyAction, proxy, provider.proxy_action_class, action_options)
+            plan_delegated_action(proxy, provider.proxy_action_class, action_options)
             plan_self
           end
         end
@@ -87,10 +87,37 @@ module Actions
           @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
+
+          fill_planning_errors_to_continuous_output(continuous_output) unless exit_status
+            
+          continuous_output.add_output(_('Exit status: %s') % exit_status, 'stdout', final_timestamp) if exit_status
+        rescue => e
+          continuous_output.add_exception(_('Error loading data from proxy'), e)
+        end
+
         def required?
           input.fetch(:required, true)
         end
 
+        def humanized_name
+          input[:feature_name].titleize
+        end
+
         def rescue_strategy_for_self
           required? ? ::Dynflow::Action::Rescue::Fail : ::Dynflow::Action::Rescue::Skip
         end
@@ -101,27 +128,6 @@ module Actions
           @host ||= ::Host.find(input[:host][:id])
         end
 
-        def determine_proxy!(proxy_selector, provider, host)
-          proxy = proxy_selector.determine_proxy(host, provider)
-          if proxy == :not_available
-            offline_proxies = proxy_selector.offline
-            settings = { count: offline_proxies.count, proxy_names: offline_proxies.map(&:name).join(', ') }
-            raise n_('The only applicable proxy %{proxy_names} is down',
-                     'All %{count} applicable proxies are down. Tried %{proxy_names}',
-                     offline_proxies.count) % settings
-          elsif proxy == :not_defined
-            settings = {
-              global_proxy: 'remote_execution_global_proxy',
-              fallback_proxy: 'remote_execution_fallback_proxy',
-              provider: provider,
-            }
-
-            raise _('Could not use any proxy for the %{provider} job. Consider configuring %{global_proxy}, ' +
-                    '%{fallback_proxy} in settings') % settings
-          end
-          proxy
-        end
-
       end
     end
   end

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

@@ -3,7 +3,6 @@ module Actions
     module Invocation
       class Patch < Actions::EntryAction
         include ::Actions::Helpers::WithContinuousOutput
-        include ::Actions::ForemanPatch::Invocation::ProcessLogging
 
         execution_plan_hooks.use :update_status, on: ::Dynflow::ExecutionPlan.states
 
@@ -31,6 +30,7 @@ module Actions
 
         def update_status(execution_plan)
           return unless root_action?
+          return if input[:invocation_id].nil?
 
           case execution_plan.state
           when :scheduled, :pending, :planning, :planned
@@ -53,16 +53,8 @@ module Actions
         end
 
         def continuous_output_providers
-          super << self
-        end
-
-        def fill_continuous_output(continuous_output)
-          invocation.events.order(:sequence).find_each do |output|
-            if output.event_type == 'exit'
-              continuous_output.add_output(_('Exit status: %s') % output.event, 'stdout', output.timestamp)
-            else
-              continuous_output.add_raw_output(output.as_raw_continuous_output)
-            end
+          planned_actions.select do |action|
+            action.respond_to?(:fill_continuous_output)
           end
         end
 
@@ -80,11 +72,7 @@ module Actions
         end
 
         def humanized_name
-          _('Patch:')
-        end
-
-        def humanized_input
-          host.name
+          _('Patch %s') % host.name
         end
 
         private
@@ -93,6 +81,10 @@ module Actions
           @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 }

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

@@ -2,8 +2,8 @@ module Actions
   module ForemanPatch
     module Invocation
       class WaitForHost < Actions::EntryAction
+        include Actions::Helpers::WithContinuousOutput
         include Dynflow::Action::Polling
-        include ::Actions::ForemanPatch::Invocation::ProcessLogging
 
         def plan(host)
           action_subject(host)
@@ -31,7 +31,7 @@ module Actions
           status = 'starting'
         ensure
           socket.close if socket
-          log_invocation_event("Poll result: #{status}")
+          add_output("Poll result: #{status}")
         end
 
         def poll_intervals
@@ -46,15 +46,30 @@ module Actions
         end
 
         def on_finish
-          log_invocation_event(_('Host is up'), 'stdout') if external_task == 'available'
+          add_output(_('Host is up'), 'stdout') if external_task == 'available'
         end
 
         def process_timeout
-          log_invocation_event(_('Server did not respond withing alloted time after restart.'), 'stderr')
+          add_output(_('Server did not respond withing alloted time after restart.'), 'stderr')
 
           self.external_task = 'timeout'
         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
@@ -65,6 +80,16 @@ module Actions
           external_task == '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

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

@@ -72,11 +72,7 @@ module Actions
         end
 
         def humanized_name
-          'Patch Group:'
-        end
-
-        def humanized_input
-          round.name
+          'Patch Group: %s' % round.name
         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, 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/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, 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

@@ -23,11 +23,7 @@ module Actions
         end
 
         def humanized_name
-          _('Publish ticket for:')
-        end
-
-        def humanized_input
-          window.name
+          _('Publish ticket for %s') % window.name
         end
 
       end

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

@@ -22,11 +22,7 @@ module Actions
         end
 
         def humanized_name
-          _('Resolve Hosts for:')
-        end
-
-        def humanized_input
-          window.name
+          _('Resolve Hosts for %s') % window.name
         end
 
       end

data/app/models/foreman_patch/invocation.rb

@@ -2,8 +2,6 @@ module ForemanPatch
   class Invocation < ::ApplicationRecord
     include ForemanTasks::Concerns::ActionSubject
 
-    STATUSES = %w(planned pending running success warning error cancelled)
-
     belongs_to :round, class_name: 'ForemanPatch::Round', inverse_of: :invocations
     has_one :window, through: :round
     has_one :cycle, through: :window
@@ -12,8 +10,6 @@ module ForemanPatch
 
     belongs_to :task, class_name: 'ForemanTasks::Task'
 
-    has_many :events, class_name: 'ForemanPatch::Events'
-
     scope :planned, -> { where(status: 'planned') }
     scope :pending, -> { where(status: 'pending') }
     scope :running, -> { where(status: 'running') }
@@ -34,6 +30,10 @@ module ForemanPatch
       task&.main_action&.planned_actions || []
     end
 
+    def events
+      task&.main_action&.live_output || []
+    end
+
     def complete?
       ['success', 'warning', 'failed', 'cancelled'].include? status
     end

data/app/models/foreman_patch/round.rb

@@ -2,8 +2,6 @@ module ForemanPatch
   class Round < ::ApplicationRecord
     include ForemanTasks::Concerns::ActionSubject
 
-    STATUSES = %w(planned pending running complete).freeze
-
     belongs_to :window, class_name: 'ForemanPatch::Window'
     has_one :cycle, class_name: 'ForemanPatch::Cycle', through: :window
     belongs_to :group, class_name: 'ForemanPatch::Group'
@@ -34,8 +32,29 @@ module ForemanPatch
     scoped_search on: :name, complete_value: true
     scoped_search on: :status, complete_value: true
 
-    def progress
-      ForemanPatch::Invocation::STATUSES.product([0]).to_h.merge(invocations.unscope(:order).group(:status).count)
+    def progress(total = nil, done = nil)
+      if invocations.empty? || done == 0
+        0
+      else
+        total ||= invocations.count
+        done ||= sub_tasks.where(result: %w(success warning error)).count
+        ((done.to_f / total) * 100).round
+      end
+    end
+
+    def progress_report
+      invocations.reduce({
+        pending: 0,
+        running: 0,
+        success: 0,
+        warning: 0,
+        failed: 0,
+        cancelled: 0,
+      }) do |report, invocation|
+        status = (invocation.status == 'planned' ? 'pending' : invocation.status)
+        report[status.to_sym] += 1
+        report
+      end
     end
 
     def finished?