foreman_patch 1.1.1

data/app/helpers/foreman_patch/plans_helper.rb

@@ -0,0 +1,45 @@
+module ForemanPatch
+  module PlansHelper
+
+    def plan_actions(plan)
+      links = []
+
+      links << link_to(_('Create Window'), new_plan_window_plan_path(plan_id: @plan.id),
+                       class: 'btn btn-default',
+                       title: _('Create a new window for this plan'))
+
+      links << link_to(_('Edit'), edit_plan_path(@plan),
+                       class: 'btn btn-default',
+                       title: _('Edit this plan'))
+
+      links << link_to(_('Run'), iterate_plan_path(@plan),
+                       class: 'btn btn-primary',
+                       title: _('Manually Iterate Plan'),
+                       method: :post)
+
+      links
+    end
+
+    def plan_windows(plan, day)
+      day = (day - plan.start_date).to_i
+
+      plan.window_plans.select do |window|
+        window.start_day == day
+      end
+    end
+
+    def plan_window_actions(window)
+      actions = []
+
+      actions << link_to(_('Edit'), edit_window_plan_path(window))
+      actions << link_to(_('Delete'), hash_for_window_plan_path(id: window), data: { confirm: _('Are you sure?') }, action: :destroy)
+
+      actions
+    end
+
+    def plan_last_window_day(plan)
+      (plan.frequency.to_i / ActiveSupport::Duration::SECONDS_PER_DAY) - 1
+    end
+
+  end
+end

data/app/helpers/foreman_patch/ticket_helper.rb

@@ -0,0 +1,11 @@
+module ForemanPatch
+  module TicketHelper
+
+    def ticket_link(window, options = {})
+      body = options.delete(:body) || window.ticket.label
+
+      link_to body, window.ticket.link, options
+    end
+
+  end
+end

data/app/helpers/foreman_patch/window_patching_helper.rb

@@ -0,0 +1,20 @@
+module ForemanPatch
+  module WindowPatchingHelper
+
+    def rounds(window)
+      window.rounds.map do |round|
+        {
+          name: round.name,
+          link: round_path(round),
+          priority: round.priority,
+          hostsCount: round.invocations.count,
+          hostsLink: main_app.hosts_path(search: "patch_round_id = #{round.id}"),
+          status: round.status,
+          actions: []
+        }
+      end
+    end
+
+  end
+end
+

data/app/helpers/foreman_patch/window_plans_helper.rb

@@ -0,0 +1,13 @@
+module ForemanPatch
+  module WindowPlansHelper
+
+    def plan_length(plan)
+      (plan.start_date - plan.end_date).to_i
+    end
+
+    def time_local_f(f, attr, options = {})
+      react_form_input('time', f, attr, options)
+    end
+
+  end
+end

data/app/helpers/foreman_patch/windows_helper.rb

@@ -0,0 +1,17 @@
+module ForemanPatch
+  module WindowsHelper
+
+    def round_move_buttons(group)
+      return 'TODO'
+      buttons = []
+
+      groups_hash = group.window.rounds.group_by(&:priority).to_hash
+
+      buttons.push(link_to(_('Move up'), hash_for_move_round_path(id: group, direction: :up), method: :post)) unless priority == 1
+      buttons.push(link_to(_('Move down'), hash_for_move_round_path(id: group, direction: :down), method: :post)) unless priority == last
+
+      action_buttons(*buttons) unless buttons.empty?
+    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

@@ -0,0 +1,69 @@
+module Actions
+  module ForemanPatch
+    module Cycle
+      class Create < Actions::EntryAction
+
+        def resource_locks
+          :link
+        end
+
+        def plan(plan)
+          action_subject(plan)
+
+          cycle = ::ForemanPatch::Cycle.create!(plan.to_params)
+
+          concurrence do
+            plan.window_plans.each do |window_plan|
+              plan_action(Actions::ForemanPatch::Window::Create, window_plan, cycle)
+            end
+          end
+
+          plan.start_date = plan.next_cycle_start
+          plan.save!
+
+          plan_self(cycle: cycle.to_action_input)
+        end
+
+        def run
+          output.update(cycle: cycle.to_action_input)
+
+          users = ::User.select { |user| user.receives?(:patch_cycle_planned) }.compact
+
+          begin
+            MailNotification[:patch_cycle_planned].deliver(users: users, cycle: cycle) unless users.blank?
+          rescue => error
+            Rails.logger.error(error)
+          end
+        end
+
+        def finalize
+          plan = ::ForemanPatch::Plan.find(input[:plan][:id])
+
+          ::ForemanTasks.delay(Actions::ForemanPatch::Cycle::Initiate, delay_options, cycle, plan)
+
+          plan.iterate
+        end
+
+        def cycle
+          @cycle ||= ::ForemanPatch::Cycle.find(input[:cycle][:id])
+        end
+
+        def humanized_name
+          _('Create cycle: %s') % input[:plan][:name]
+        end
+
+        private
+
+        def delay_options
+          Time.use_zone(Setting[:patch_schedule_time_zone]) do
+            {
+              start_at: cycle.start_date.beginning_of_day,
+            }
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,68 @@
+module Actions
+  module ForemanPatch
+    module Cycle
+      class Initiate < Actions::EntryAction
+
+        def delay(delay_options, cycle, plan = nil)
+          input.update serialize_args(cycle: cycle)
+          add_missing_task_group(plan) if plan.present?
+
+          super delay_options, cycle
+        end
+
+        def plan(cycle, plan = nil)
+          input.update serialize_args(cycle: cycle)
+          add_missing_task_group(plan) if plan.present?
+
+          cycle.windows.each do |window|
+            plan_action(Actions::ForemanPatch::Window::ResolveHosts, window)
+          end
+          plan_self
+        end
+
+        def run
+          content_view_versions = cycle.hosts.map do |host|
+            host.content_view.version(host.lifecycle_environment)
+          end.uniq
+
+          content_view_versions.each do |version|
+            next unless available_content?(version)
+
+            ::ForemanTasks.async_task(Actions::ForemanPatch::Cycle::PrepareContent, version, _('Updating content for patch cycle: %s') % cycle.name)
+          end
+        end
+
+        def finalize
+          cycle.windows.each(&:schedule)
+
+          cycle.plan.iterate if cycle.plan.present?
+        end
+
+        def humanized_name
+          _('Initiating patch cycle: %s') % cycle.name
+        end
+
+        def cycle
+          @cycle ||= ::ForemanPatch::Cycle.find(input[:cycle][:id])
+        end
+
+        private
+
+        def available_content?(version)
+          version.available_packages.any? or 
+            version.available_errata.any? or
+            ::Katello::Deb.in_repositories(version.library_repos).where.not(id: version.debs).any?
+        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/cycle/plan.rb

@@ -0,0 +1,73 @@
+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
+            creation = plan_action(::Actions::ForemanPatch::Cycle::Create, params(plan))
+
+            concurrence do
+              plan.window_plans.each do |window_plan|
+                plan_action(::Actions::ForemanPatch::Window::Plan, window_plan, creation.output[:cycle])
+              end
+            end
+
+            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/cycle/prepare_content.rb

@@ -0,0 +1,123 @@
+module Actions
+  module ForemanPatch
+    module Cycle
+      class PrepareContent < Actions::EntryAction
+        include ::Katello::ContentViewHelper
+
+        def humanized_name
+          _('Minor Version Update')
+        end
+
+        def plan(old_version, description)
+          action_subject(old_version.content_view)
+
+          new_minor = old_version.content_view.versions.where(major: old_version.major).maximum(:minor) + 1
+
+          components = []
+
+          sequence do
+            if old_version.content_view.composite?
+              components = update_components(old_version.components, description)
+            end
+
+            new_version = old_version.content_view.create_new_version(old_version.major, new_minor, components)
+
+            history = ::Katello::ContentViewHistory.create!(content_view_version: new_version,
+                                                            user: ::User.current.login,
+                                                            action: ::Katello::ContentViewHistory.actions[:publish],
+                                                            status: ::Katello::ContentViewHistory::IN_PROGRESS,
+                                                            task: self.task,
+                                                            notes: description)
+
+            repositories = collect_repositories(old_version, components)
+
+            repository_mapping = plan_action(Actions::Katello::ContentViewVersion::CreateRepos,
+                                             new_version, repositories).repository_mapping
+
+            separated_repo_map = separated_repo_mapping(repository_mapping, true)
+
+            if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present? &&
+                SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum_multicopy].keys.flatten.first)
+              
+              plan_action(Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], new_version)
+            end
+
+            concurrence do
+              repositories.each do |repository|
+                plan_action(Actions::Katello::Repository::CloneToVersion,
+                            repository, new_version, repository_mapping[repository])
+              end
+            end
+
+            plan_self(new_version_id: new_version.id,
+                      history_id: history.id,
+                      old_version_id: old_version.id)
+            plan_action(Actions::Katello::ContentView::Promote, new_version, old_version.environments, true)
+          end
+        end
+
+        def finalize
+          new_version.update_content_counts!
+
+          history.status = ::Katello::ContentViewHistory::SUCCESSFUL
+          history.save!
+        end
+
+        def new_version
+          @new_version ||= ::Katello::ContentViewVersion.find(input[:new_version_id])
+        end
+
+        private
+
+        def old_version
+          @old_version ||= ::Katello::ContentViewVersion.find(input[:old_version_id])
+        end
+
+        def history
+          @history ||= ::Katello::ContentViewHistory.find(input[:history_id])
+        end
+
+        def available_content?(version)
+          version.available_packages.any? or
+            version.available_errata.any? or
+            ::Katello::Deb.in_repositories(version.library_repos).where.not(id: version.debs).any?
+        end
+
+        def collect_repositories(version, components)
+          repositories = []
+          if version.content_view.composite?
+            ids = components.flat_map { |component| component.repositories.archived }.map(&:id)
+            repositories = ::Katello::Repository.where(id: ids)
+          else
+            repositories = version.library_repos
+          end
+          repositories.map do |repo|
+            if repo.is_a? Array
+              repo
+            else
+              [repo]
+            end
+          end
+        end
+
+        def update_components(components, description)
+          new_components = []
+          concurrence do
+            components.each do |component|
+              if available_content?(component)
+                new_components << plan_action(Actions::ForemanPatch::Cycle::PrepareContent,
+                                              component, description).new_version
+              else
+                new_components << component
+              end
+            end
+          end
+          new_components
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,32 @@
+module Actions
+  module ForemanPatch
+    module Host
+      class Reschedule < Actions::Base
+
+        def plan(*hosts, **options)
+          hosts = hosts.flatten
+          input.update(**options, hosts: hosts.map(&:to_action_input))
+
+          statuses = ['planned']
+          statuses << 'scheduled' if options.fetch(:include_active, false)
+
+          # this query must be converted to array otherwise changes will alter the results
+          windows = ::ForemanPatch::Window.with_hosts(hosts).with_status(statuses).to_a
+
+          sequence do
+            ::ForemanPatch::Invocation.in_windows(windows).where(host: hosts).each do |invocation|
+              plan_action(Actions::ForemanPatch::Invocation::Reschedule, invocation)
+            end
+            ::ForemanPatch::Round.in_windows(windows).missing_hosts(hosts).each do |round|
+              plan_action(Actions::ForemanPatch::Round::AddMissingHosts, round, hosts)
+            end
+
+            plan_action(Actions::BulkAction, Actions::ForemanPatch::Window::Publish, windows) unless windows.empty?
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,135 @@
+module Actions
+  module ForemanPatch
+    module Invocation
+      class Action < ::Actions::EntryAction
+        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 resource_locks
+          :link
+        end
+
+        def plan(host, feature_name, required = true, **input_values)
+          action_subject(host, feature_name: feature_name, required: required, **input_values)
+
+          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)
+
+          sequence do
+            plan_delegated_action(proxy, provider.proxy_action_class, action_options)
+            plan_self
+          end
+        end
+
+        def run
+          if exit_status != 0
+            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?
+            fail(_('Patch step failed: %{step}') % {step: humanized_name})
+          end
+        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
+
+          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
+
+        private
+
+        def host
+          @host ||= ::Host.find(input[:host][:id])
+        end
+
+      end
+    end
+  end
+end
+