foreman_patch 1.1.1

data/app/models/foreman_patch/plan.rb

@@ -0,0 +1,110 @@
+module ForemanPatch
+  class Plan < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    UNITS = ['days', 'weeks', 'months', 'years'].freeze
+    CORRECTIONS = ['weekday', 'last_day', 'last_weekday', 'avoid_weekend'].freeze
+
+    has_many :window_plans, class_name: 'ForemanPatch::WindowPlan', foreign_key: :plan_id, dependent: :delete_all, inverse_of: :plan
+
+    has_many :cycles, -> { order(start_date: :desc) }, class_name: 'ForemanPatch::Cycle', foreign_key: :plan_id, dependent: :nullify
+
+    belongs_to :task_group, class_name: 'ForemanPatch::PlanTaskGroup', inverse_of: :plan
+    has_many :tasks, through: :task_group, class_name: 'ForemanTasks::Task'
+
+    validates :name, presence: true, uniqueness: true
+    validates :units, inclusion: {in: UNITS}, allow_blank: false
+    validates :correction, inclusion: {in: CORRECTIONS}, allow_blank: true
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :units, complete_value: true
+    scoped_search on: :interval, complete_value: true
+    scoped_search on: :start_date, complete_value: false
+
+    before_destroy :stop
+
+    def end_date
+      next_cycle_start - 1.day
+    end
+
+    def frequency
+      interval.send(units)
+    end
+
+    def stopped?
+      active_count == 0
+    end
+
+    def stop
+      self.active_count = 0
+      save!
+      tasks.active.each(&:cancel)
+    end
+
+    def next_cycle_start
+      next_date = start_date + frequency
+      next_date = send(correction, next_date) unless correction.blank?
+      next_date
+    end
+
+    def iterate
+      count = tasks.where(state: 'scheduled').count
+
+      if count < active_count or active_count == 0
+        ForemanTasks.async_task(Actions::ForemanPatch::Cycle::Create, self)
+      end
+    end
+
+    def to_params
+      {
+        name: ForemanPatch::CycleNameGenerator.generate(self),
+        start_date: start_date,
+        end_date: next_cycle_start - 1.day,
+      }
+    end
+
+    class Jail < Safemode::Jail
+      allow :start_date, :end_date, :frequency, :name, :interval, :units
+    end
+
+    private
+
+    def weekday(next_date)
+      offset = (next_date.day - 1) % 7
+      shift = start_date.wday - (next_date.wday - offset)
+      shift += 7 if shift < 0
+      next_date.advance(days: shift - offset)
+    end
+
+    def last_day(next_date)
+      next_date.end_of_month
+    end
+
+    def last_weekday(next_date)
+      next_date = next_date.end_of_month
+      ago = next_date.wday - start_date.wday
+      ago += 7 unless ago >= 0
+      next_date.advance(days: -ago)
+    end
+
+    def avoid_weekend(next_date)
+      if next_date.saturday?
+        (next_date.day == 1 ? next_date.advance(days: 2) : next_date.advance(days: -1))
+      elsif next_date.sunday?
+        (next_date.day == ::Time.days_in_month(next_date.month, next_date.year) ? next_date.advance(days: -2) : next_date.advance(days: 1))
+      else
+        next_date
+      end
+    end
+
+    def delay_options
+      Time.use_zone(Setting[:patch_schedule_time_zone]) do
+        {
+          start_at: start_date.beginning_of_day
+        }
+      end
+    end
+
+  end
+end
+

data/app/models/foreman_patch/plan_task_group.rb

@@ -0,0 +1,11 @@
+module ForemanPatch
+  class PlanTaskGroup < ::ForemanTasks::TaskGroup
+    has_one :plan, foreign_key: :task_group_id, dependent: :nullify, inverse_of: :task_group, class_name: 'ForemanPatch::Plan'
+
+    alias_method :resource, :plan
+
+    def resource_name
+      N_('Plan')
+    end
+  end
+end

data/app/models/foreman_patch/round.rb

@@ -0,0 +1,68 @@
+module ForemanPatch
+  class Round < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    belongs_to :window, class_name: 'ForemanPatch::Window'
+    has_one :cycle, class_name: 'ForemanPatch::Cycle', through: :window
+    belongs_to :group, class_name: 'ForemanPatch::Group'
+
+    belongs_to :task, class_name: 'ForemanTasks::Task'
+    has_many :sub_tasks, through: :task
+
+    validates :window, presence: true
+
+    has_many :invocations, class_name: 'ForemanPatch::Invocation', foreign_key: :round_id, inverse_of: :round, dependent: :destroy
+    has_many :hosts, through: :invocations
+
+    scope :planned, -> { where(status: 'planned') }
+    scope :pending, -> { where(status: 'pending') }
+    scope :running, -> { where(status: 'running') }
+    scope :complete, -> { where(status: 'complete') }
+
+    scope :in_windows, -> (*args) { where(window: args.flatten) }
+    scope :missing_hosts, -> (*args) do
+      left_joins(:invocations, { group: :group_facets }).scoping do
+        where(foreman_patch_group_facets: { host_id: args.flatten },
+              foreman_patch_invocations: { host_id: nil })
+      end
+    end
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :status, complete_value: true
+
+    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?
+      !(task.nil? || task.pending?)
+    end
+
+    class Jail < ::Safemode::Jail
+      allow :id, :name, :description, :invocations, :hosts, :priority, :max_unavailable, :status 
+    end
+
+  end
+end
+

data/app/models/foreman_patch/ticket_field.rb

@@ -0,0 +1,23 @@
+module ForemanPatch
+  class TicketField < LookupKey
+
+    def ticket?
+      true
+    end
+
+    def self.humanized_class_name(options = nil)
+    end
+
+    def path
+      path = self[:path]
+      path.presence || array2path(['name', 'cycle'])
+    end
+
+    def path=(value)
+      return unless value
+      using_default = value.tr("\r", "") == array2path(['name', 'cycle'])
+      self[:path] = using_default ? nil : value
+    end
+
+  end
+end

data/app/models/foreman_patch/window.rb

@@ -0,0 +1,123 @@
+module ForemanPatch
+  class Window < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    belongs_to :cycle, class_name: 'ForemanPatch::Cycle', inverse_of: :windows
+
+    belongs_to :task, class_name: 'ForemanTasks::Task'
+    has_many :sub_tasks, through: :task
+
+    has_many :rounds, -> { order(priority: :asc) }, class_name: 'ForemanPatch::Round', inverse_of: :window, dependent: :destroy
+    has_many :groups, through: :rounds
+    has_many :invocations, through: :rounds
+    has_many :hosts, through: :rounds
+
+    validates :cycle, presence: true
+    validates :name, presence: true
+    validates :start_at, presence: true
+    validates :end_by, presence: true
+
+    scope :planned, -> { where(status: 'planned') }
+    scope :scheduled, -> { where(status: 'scheduled') }
+    scope :running, -> { where(status: 'running') }
+    scope :completed, -> { where(status: 'completed') }
+
+    scope :with_status, -> (*args) { where(status: args.flatten) }
+    scope :with_hosts, -> (*args) do
+      left_joins(rounds: [:invocations, {group: :group_facets}]).scoping do
+        where(foreman_patch_group_facets: { host_id: args.flatten })
+          .or(where(foreman_patch_invocations: { host_id: args.flatten }))
+      end
+    end
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :start_at, complete_value: false
+    scoped_search on: :end_by, complete_value: false
+    scoped_search on: :cycle_id, complete_value: false
+    scoped_search on: :status, complete_value: true
+    scoped_search relation: :cycle, on: :name, complete_value: true, rename: 'cycle', only_explicit: true
+
+    after_update :reschedule, if: :needs_reschedule?
+    after_update :republish, if: :needs_republish?
+
+    def ticket
+      @ticket ||= Ticket.get(self)
+    end
+
+    def duration
+      end_by - start_at
+    end
+
+    def duration=(duration)
+      self.end_by = start_at + duration
+    end
+
+    def move_to(time)
+      span = duration
+      self.start_at = time
+      self.end_by = time + span
+    end
+
+    def move_by(duration)
+      self.start_at = self.start_at + duration
+      self.end_by = self.end_by + duration
+    end
+
+    class Jail < ::Safemode::Jail
+      allow :id, :name, :description, :cycle, :start_at, :end_by, :rounds
+    end
+
+    def scheduled?
+      (not task.blank?) and task.scheduled?
+    end
+
+    def schedule
+      User.as_anonymous_admin do
+        ::ForemanTasks.delay(::Actions::ForemanPatch::Window::Patch, delay_options, self) unless scheduled?
+      end
+    end
+
+    def cancel(force = false)
+      method = force ? :abort : :cancel
+      task.send(method) unless task.blank?
+    end
+
+    def published?
+      not ticket_id.blank?
+    end
+
+    private
+
+    def needs_reschedule?
+      scheduled? and (saved_changes.keys & ['start_at', 'end_by']).any?
+    end
+
+    def reschedule
+      User.as_anonymous_admin do
+        task.cancel
+        task.destroy
+
+        ::ForemanTasks.delay(::Actions::ForemanPatch::Window::Patch, delay_options, self)
+      end
+    end
+
+    def needs_republish?
+      published? and (saved_changes.keys - ['ticket_id', 'updated_at']).any?
+    end
+
+    def republish
+      User.as_anonymous_admin do
+        ::ForemanTasks.async_task(::Actions::ForemanPatch::Window::Publish, self)
+      end
+    end
+
+    def delay_options
+      {
+        start_at: start_at,
+        start_before: end_by,
+      }
+    end
+
+  end
+end
+

data/app/models/foreman_patch/window_plan.rb

@@ -0,0 +1,77 @@
+module ForemanPatch
+  class WindowPlan < ::ApplicationRecord
+    include ForemanTasks::Concerns::ActionSubject
+
+    attr_accessor :start_at, :end_by
+
+    self.skip_time_zone_conversion_for_attributes = [:start_time]
+
+    belongs_to :plan, class_name: 'ForemanPatch::Plan', inverse_of: :window_plans
+
+    has_many :groups, class_name: 'ForemanPatch::Group', foreign_key: :default_window_plan_id
+
+    validates :name, presence: true, uniqueness: { scope: :plan_id }
+    validates :start_day, presence: true
+    validates :start_time, presence: true
+    validates :duration, presence: true
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :plan_id, complete_value: true
+    scoped_search on: :start_day, complete_value: true
+    scoped_search on: :start_time, complete_value: true
+
+    scoped_search relation: :plan, on: :name, complete_value: true
+
+    after_initialize :init
+
+    def start_time
+      value = read_attribute(:start_time)
+      return nil if value.blank?
+
+      if value.acts_like?(:time)
+        args = [value.year, value.month, value.day, value.hour, value.min, value.sec]
+        time = Time.find_zone(Setting[:patch_schedule_time_zone]).local(*args)
+      else
+        time = Time.find_zone(Setting[:patch_schedule_time_zone]).parse(value)
+      end
+      time.to_time
+    end
+
+    def start_time=(value)
+      if value.acts_like?(:time)
+        time = value.in_time_zone(Setting[:patch_schedule_time_zone]).time
+      else
+        time = Time.find_zone(Setting[:patch_schedule_time_zone]).parse(value).time
+      end
+      write_attribute(:start_time, time)
+    end
+
+    def start_at
+      start_date = plan.start_date + start_day.days
+      start_time.change(year: start_date.year, month: start_date.month, day: start_date.day)
+    end
+
+    def end_by
+      start_at + duration
+    end
+
+    def to_params
+      {
+        name: name,
+        description: description,
+        start_at: start_at,
+        end_by: end_by,
+      }
+    end
+
+    private
+
+    def init
+      self.start_day ||= 0
+      self.start_time ||= Time.find_zone(Setting[:patch_schedule_time_zone]).parse('00:00:00')
+      self.duration ||= 1.hour.to_i
+    end
+
+  end
+end
+

data/app/models/foreman_patch/window_task_group.rb

@@ -0,0 +1,11 @@
+module ForemanPatch
+  class WindowTaskGroup < ::ForemanTasks::TaskGroup
+    has_one :window, foreign_key: :task_group_id, dependent: :nullify, class_name: 'ForemanPatch::Window'
+
+    alias_method :resource, :window
+
+    def resource_name
+      N_('Window')
+    end
+  end
+end

data/app/models/setting/patching.rb

@@ -0,0 +1,57 @@
+class Setting::Patching < ::Setting
+  def self.default_settings
+    http_proxy_select = [{
+      name: _('Http Proxies'),
+      class: 'HttpProxy',
+      scope: 'all',
+      value_method: 'name',
+      text_method: 'name_and_url',
+    }]
+
+    time_zone_select = [{
+      name: _('Time Zones'),
+      class: 'ActiveSupport::TimeZone',
+      scope: 'all',
+      value_method: 'name',
+      text_method: 'name',
+    }]
+
+    # set(name, description, default, fullname, value, { options })
+    [
+      self.set('host_max_wait_for_up', N_("Maximum seconds to wait for a host after patching restart."),
+               600, N_("Max wait for host up")),
+      self.set('host_patch_timeout', N_("Maximum seconds for a patching invocation to run before timing out"),
+               nil, N_('Patch Timeout')),
+      self.set('patch_schedule_time_zone', N_('Time zone used to base patch window scheduling off of.'),
+               'UTC', N_('Patch Schedule Time Zone'), nil,
+               collection: proc { time_zone_select }),
+      self.set('ticket_api_host', N_('Host used for change management tickets'),
+               nil, N_('Ticket API host')),
+      self.set('ticket_api_proxy', N_('HTTP Proxy to access ticket API host'),
+               nil, N_('Ticket API HTTP proxy'), nil,
+               collection: proc { http_proxy_select }, include_blank: N_('no proxy')),
+      self.set('ticket_api_user', N_('User with access to ticket API'),
+               nil, N_('Ticket API user')),
+      self.set('ticket_api_password', N_('Password for ticket API user'),
+               nil, N_('Ticket API password'), nil, { encrypted: true }),
+      self.set('ticket_api_path', N_('Ticket API path for REST/CRUD operations'),
+               '/api/now/table/change_request', N_('Ticket API path')),
+      self.set('ticket_web_ui_path', N_('Path for opening a ticket in the web UI'),
+               '/change_request.do?sys_id=:id', N_('Ticket Web UI path')),
+      self.set('ticket_label_field', N_('Name of the field used for the ticket label'),
+               'number', N_('Ticket label field')),
+      self.set('ticket_id_field', N_('Name of the field used for the ticket id'),
+               'sys_id', N_('Ticket ID field')),
+      self.set('skip_broken_patches', N_('Skip broken dependencies during patching'), true, N_('Skip broken patches'))
+    ]
+  end
+
+  def self.humanized_category
+    N_('Patching')
+  end
+
+  def self.load_defaults
+    BLANK_ATTRS.concat %w(ticket_api_host ticket_api_proxy ticket_api_user ticket_api_password, host_patch_timeout)
+    super
+  end
+end

data/app/services/foreman_patch/cycle_name_generator.rb

@@ -0,0 +1,38 @@
+module ForemanPatch
+  class CycleNameGenerator
+    REGEX = /%([-_0^#:]*)(\d*)([q])/.freeze
+
+    def self.generate(plan)
+      return plan.name if plan.cycle_name.blank?
+
+      generator = new(plan.cycle_name, plan.start_date)
+      generator.render
+    end
+
+    def self.rename(cycle)
+      return if cycle.plan.blank?
+      return if cycle.plan.cycle_name.blank?
+
+      generator = new(cycle.plan.cycle_name, cycle.start_date)
+      cycle.update(name: generator.render)
+    end
+
+    attr_accessor :format, :date
+
+    def initialize(format, date)
+      @format = format
+      @date = date
+    end
+
+    def render
+      date.strftime(format.gsub(REGEX, quarter(date)))
+    end
+
+    private
+
+    def quarter(date)
+      (date.month / 3.0).ceil.to_s
+    end
+
+  end
+end

data/app/services/foreman_patch/ticket/affected_items.rb

@@ -0,0 +1,110 @@
+module ForemanPatch
+  module Ticket
+    class AffectedItems
+      include API
+
+      attr_reader :ticket
+
+      def initialize(ticket)
+        @ticket = ticket
+      end
+
+      def items
+        @items ||= get_affected_items
+      end
+
+      def set(hosts)
+        cmdb_items = get_configuration_items(hosts)
+
+        add_affected_items(select_cmdb_items(cmdb_items, true))
+
+        remove_affected_items(select_affected_items(cmdb_items, true))
+
+        @items = get_affected_items
+      end
+
+      def add(hosts)
+        add_affected_items(select_cmdb_items(get_configuration_items(hosts), true))
+
+        @items = get_affected_items
+      end
+
+      def remove(hosts)
+        remove_affected_items(select_affected_items(get_configuration_items(hosts)))
+
+        @items = get_affected_items
+      end
+
+      private
+
+      def get_configuration_items(hosts)
+        params = {
+          sysparm_query: "host_nameIN#{hosts.map(&:name).join(',')}",
+          sysparm_exclude_reference_link: true,
+          sysparm_fields: 'sys_id,host_name',
+        }
+
+        get('/api/now/table/cmdb_ci_server', params)
+
+        response.nil? ? [] : response['result']
+      end
+
+      def get_affected_items
+        params = {
+          sysparm_query: "task=#{ticket.id}",
+          sysparm_exclude_reference_link: true,
+          sysparm_fields: 'sys_id,task,ci_item',
+        }
+
+        get('/api/now/table/task_ci', params)
+
+        response.nil? ? [] : response['result']
+      end
+
+      def select_cmdb_items(cmdb_items, inverse = false)
+        affected_item_ids = get_affected_items.map { |i| i['cm_item'] }
+        cmdb_items.select do |cmdb_item|
+          inverse ^ (affected_item_ids.include? cmdb_item['sys_id'])
+        end
+      end
+
+      def select_affected_items(cmdb_items, inverse = false)
+        cmdb_item_ids = cmdb_items.map { |i| i['sys_id'] }
+        items.select do |affected_item|
+          inverse ^ (cmdb_item_ids.include? affected_item['ci_item'])
+        end
+      end
+
+      def add_affected_items(cmdb_items)
+        cmdb_items.each do |ci_item|
+          add_affected_item(ci_item)
+        end
+      end
+
+      def add_affected_item(cmdb_ci)
+        params = {
+          sysparm_exclude_reference_link: true,
+          sysparm_fields: 'sys_id,task,ci_item',
+        }
+
+        payload = {
+          ci_item: cmdb_ci['sys_id'],
+          task: ticket.id,
+        }
+
+        post('/api/now/table/task_ci', payload, params)
+      end
+
+      def remove_affected_items(affected_items)
+        affected_items.each do |affected_item|
+          remove_affected_item(affected_item)
+        end
+      end
+
+      def remove_affected_item(affected_item)
+        delete("/api/now/table/task_ci/#{affected_item['sys_id']}")
+      end
+
+    end
+  end
+end

data/app/services/foreman_patch/ticket/api.rb

@@ -0,0 +1,68 @@
+module ForemanPatch
+  module Ticket
+    module API
+      attr_reader :response, :errors
+
+      private
+
+      def host
+        Setting[:ticket_api_host]
+      end
+
+      def url(path)
+        host + path
+      end
+
+      def proxy
+        return nil if Setting[:ticket_api_proxy].blank?
+
+        HttpProxy.friendly.find(Setting[:ticket_api_proxy])&.url
+      end
+
+      def get(path, params = {})
+        request(:get, path, params)
+      end
+
+      def post(path, payload, params = {})
+        request(:post, path, params, payload)
+      end
+
+      def put(path, payload, params = {})
+        request(:put, path, params, payload)
+      end
+
+      def delete(path)
+        request(:delete, path)
+      end
+
+      def request(method, path, params = {}, payload = nil)
+        @response = nil
+
+        args = {
+          method: method,
+          url: url(path),
+          headers: {
+            accept: :json,
+            content_type: :json,
+            params: params,
+          },
+          user: Setting[:ticket_api_user],
+          password: Setting[:ticket_api_password],
+        }
+
+        args[:payload] = payload.to_json unless payload.nil?
+        args[:proxy] = proxy
+
+        raw = RestClient::Request.execute(args)
+
+        @response = JSON.parse(raw)
+      rescue RestClient::ExceptionWithResponse => error
+        @errors = JSON.parse(error.response)
+        Rails.logger.error(error)
+      rescue => error
+        Rails.logger.error(error)
+      end
+
+    end
+  end
+end