foreman_maintain 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe40b2c9fdd4999acc0a0b764a916815e51c9c4a
-  data.tar.gz: cf9939ee27a333b61665f3eee0277005bfdd0167
+  metadata.gz: 3685c87a51938c933602dc6c14326eff9dcd0f17
+  data.tar.gz: aecc1a267b26067df5a4ecda9ffda31ddd278983
 SHA512:
-  metadata.gz: c3297df9601ce8f75dae19f2539b9563434d523d2f3eec602f4562bb6ce98ff29a3622f5c07c859a4da29c6f2cd38f2d90cd8d9d3531dee6b6f08bc49fdecefc
-  data.tar.gz: 67e607579907ad237d497692781c7e226352f87b9494f3cbe51aa167e67298ef500884b2099b386a002a9604432a4afa41da8c74a0b51bcf64721a5fa9a421e8
+  metadata.gz: e972a4b2e2375bc8af5190c66b897fb9604ebada63804fc57a73547b93169b4a919ff54439e4efb2c4438b19b0b10b35f6d4cfd7805043479c4954d2f31b4acd
+  data.tar.gz: 521e0c73a330a750cfeee298ca9b7d2ed9341b4e863f56cb1a791df3b774a97c1fc27352d8bec14a453549fc9bb30fd3b87da059418b6266f0aca3a5e6d6269e

data/README.md

@@ -55,10 +55,12 @@ definitions.
 
 ```ruby
 class Features::Foreman < ForemanMaintain::Feature
-  label :foreman
+  metadata do
+    label :foreman
 
-  confine do
-    check_min_version('foreman', '1.7')
+    confine do
+      check_min_version('foreman', '1.7')
+    end
   end
 
   # helper method that can be used in other definitions like this:
@@ -81,22 +83,19 @@ Checks define assertions to determine status of the system.
 
 ```ruby
 class Checks::ForemanIsRuning < ForemanMaintain::Check
-  for_feature :foreman
-
-  description 'check foreman service is running'
-
-  tags :basic
+  metadata do
+    for_feature :foreman
+    description 'check foreman service is running'
+    tags :default
+  end
 
   def run
     # we are using methods of a feature.
+    # we can define additional steps to be executed as a follow-up
+    # of assertion failure
     assert(feature(:foreman).running?
-           'There are currently paused tasks in the system')
-  end
-
-  # we can define additional steps to be executed after this check is finished
-  # based on the result
-  def next_steps
-    [procedure(Procedures::ForemanStart)] if fail?
+           'There are currently paused tasks in the system'),
+           :next_steps => Procedures::ForemanStart.new)
   end
 end
 ```
@@ -107,6 +106,23 @@ Similarly as features, also checks (and in fact all definitions) can used
 Every definition has a `label` (if not stated explicitly, it's
 determined from the class name).
 
+In case some operation take more time, it's possible to enable a spinner
+and update the spinner continuously with `with_spinner` method.
+
+```ruby
+def run
+  with_spinner do |spinner|
+    spinner.update 'checking foreman is running'
+    if feature(:foreman).running?
+      spinner.update 'foreman is not started, starting'
+      feature(:foreman).start
+    else
+      spinner.update 'foreman is started, restarting'
+    end
+  end
+end
+```
+
 ### Procedures
 
 Procedure defines some operation that can be performed against the system.
@@ -114,9 +130,10 @@ It can be part of a scenario or be linked from a check as a remediation step.
 
 ```ruby
 class Procedures::ForemanStart < ForemanMaintain::Procedure
-  for_feature :foreman
-
-  description 'start foreman service'
+  metadata do
+    for_feature :foreman
+    description 'start foreman service'
+  end
 
   def run
     feature(:foreman).start
@@ -124,6 +141,49 @@ class Procedures::ForemanStart < ForemanMaintain::Procedure
 end
 ```
 
+### Preparation steps
+
+Some steps can require some additional steps to be performed before we
+can proceed. A typical example is installing additional dependencies.
+A preparation step is usually a procedure.
+
+```ruby
+class Procedures::InstallPackage < ForemanMaintain::Procedure
+  metadata do
+    # definitions of parameters of the procedure
+    param :packages, 'List of packages to install', :array => true
+  end
+
+  def run
+    install_packages(@packages)
+  end
+
+  # if false, the step will be considered as done: it will not be executed
+  def necessary?
+    @packages.any? { |package| package_version(package).nil? }
+  end
+
+  def description
+    "Install package(s) #{@packages.join(', ')}"
+  end
+end
+
+class Checks::DiskIO < ForemanMaintain::Check
+  metadata do
+    description 'check foreman service is running'
+    preparation_steps { Procedures::InstallPackage.new(:packages => %w[hdparm]) }
+  end
+
+  def run
+    execute!('hdparam ...')
+  end
+end
+```
+
+When running a scenario, all the preparation steps in that scenario
+will be collected, and run if necessary (the `necessary?` method
+returning `true`). The preparation steps will be run as separate scenario.
+
 ### Scenarios
 
 Scenarios represent a composition of various steps (checks and procedures) to
@@ -132,22 +192,44 @@ achieve some complex maintenance operation in the system (such as upgrade).
 
 ```ruby
 class Scenarios::PreUpgradeCheckForeman_1_14 < ForemanMaintain::Scenario
-  description 'checks before upgrading to Foreman 1.14'
-
-  confine do
-    feature(:upstream)
+  metadata do
+    description 'checks before upgrading to Foreman 1.14'
+    confine do
+      feature(:upstream)
+    end
+    tags :pre_upgrade_check
   end
 
-  tags :pre_upgrade_check
-
   # Method to be called when composing the steps of the scenario
   def compose
     # we can search for the checks by metadata
-    steps.concat(find_checks(:basic))
+    steps.concat(find_checks(:default))
   end
 end
 ```
 
+### Hammer
+
+In some cases, it's useful to be able to use the hammer as part of check/fix procedures.
+The easiest way to achieve this is to include `ForemanMaintain::Concerns::Hammer` module:
+
+```ruby
+include ForemanMaintain::Concerns::Hammer
+
+def run
+  hammer('task resume')
+end
+```
+
+We expect the credentials for the hammer commands to to be stored inside the hammer settings:
+
+```
+# ~/.hammer/cli.modules.d/foreman.yml
+:foreman:
+  :username: 'admin'
+  :password: 'changeme'
+```
+
 ## Implementation components
 
 In order to process the definitions, there are other components present in the `lib` directory.

data/bin/foreman-maintain

@@ -3,6 +3,7 @@
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'foreman_maintain'
+
 ForemanMaintain.setup
 
 require 'foreman_maintain/cli'

data/definitions/checks/disk_speed_minimal.rb

@@ -1,41 +1,53 @@
 class Checks::DiskSpeedMinimal < ForemanMaintain::Check
+  metadata do
+    label :disk_io
+    description 'Check for recommended disk speed of pulp, mongodb, pgsql dir.'
+    tags :pre_upgrade
+    preparation_steps { Procedures::InstallPackage.new(:packages => %w[hdparm fio]) }
+  end
+
   EXPECTED_IO = 80
   DEFAULT_UNIT   = 'MB/sec'.freeze
   DEFAULT_DIRS   = ['/var/lib/pulp', '/var/lib/mongodb', '/var/lib/pgsql'].freeze
 
-  label :disk_io
-  description 'Check for recommended disk speed of pulp, mongodb, pgsql dir.'
-  tags :basic
+  def run
+    with_spinner(description) do |spinner|
+      io_obj, success = compute_disk_speed(spinner)
+      spinner.update('Finished')
 
-  confine do
-    execute?('which hdparm') && execute?('which fio')
+      assert(success, io_obj.slow_disk_error_msg)
+    end
   end
 
-  def run
+  def check_only_single_device?
+    DEFAULT_DIRS.map do |dir|
+      ForemanMaintain::Utils::Disk::Device.new(dir).name
+    end.uniq.length <= 1
+  end
+
+  def dirs_to_check
+    return DEFAULT_DIRS.first(1) if check_only_single_device?
+    DEFAULT_DIRS
+  end
+
+  private
+
+  def compute_disk_speed(spinner)
     success = true
     io_obj = ForemanMaintain::Utils::Disk::NilDevice.new
 
     dirs_to_check.each do |dir|
       io_obj = ForemanMaintain::Utils::Disk::Device.new(dir)
 
+      spinner.update("[Speed check In-Progress] device: #{io_obj.name}")
+
       next if io_obj.read_speed >= EXPECTED_IO
 
       success = false
-      logger.info "\n Slow disk detected for #{dir} - #{io_obj.read_speed} #{io_obj.unit}."
+      logger.info "Slow disk detected #{dir}: #{io_obj.read_speed} #{io_obj.unit}."
       break
     end
 
-    assert(success, io_obj.slow_disk_error_msg)
-  end
-
-  def check_only_single_device?
-    DEFAULT_DIRS.map do |dir|
-      ForemanMaintain::Utils::Disk::Device.new(dir).name
-    end.uniq.length <= 1
-  end
-
-  def dirs_to_check
-    return DEFAULT_DIRS.first(1) if check_only_single_device?
-    DEFAULT_DIRS
+    [io_obj, success]
   end
 end

data/definitions/checks/foreman_tasks/invalid/check_old.rb

@@ -0,0 +1,20 @@
+module Checks::ForemanTasks
+  module Invalid
+    class CheckOld < ForemanMaintain::Check
+      metadata do
+        label :check_old_foreman_tasks
+        for_feature :foreman_tasks
+        tags :pre_upgrade
+        description 'Check for old tasks in paused/stopped state'
+      end
+
+      def run
+        # Check and delete 'all tasks beyond 30 days(paused and stopped)'
+        count_old_tasks = feature(:foreman_tasks).count(:old)
+        assert(count_old_tasks <= 0,
+               "Found #{count_old_tasks} paused or stopped task(s) older than 30 days",
+               :next_steps => Procedures::ForemanTasks::Delete.new(:state => :old))
+      end
+    end
+  end
+end

data/definitions/checks/foreman_tasks/invalid/check_pending_state.rb

@@ -0,0 +1,20 @@
+module Checks::ForemanTasks
+  module Invalid
+    class CheckPendingState < ForemanMaintain::Check
+      metadata do
+        label :check_foreman_tasks_in_pending_state
+        for_feature :foreman_tasks
+        tags :pre_upgrade
+        description 'Check for pending tasks which are safe to delete'
+      end
+
+      def run
+        # Check and delete 'all tasks in pending state'
+        count_tasks_in_pending_state = feature(:foreman_tasks).count(:pending)
+        assert(count_tasks_in_pending_state <= 0,
+               "Found #{count_tasks_in_pending_state} pending task(s) which are safe to delete",
+               :next_steps => Procedures::ForemanTasks::Delete.new(:state => :pending))
+      end
+    end
+  end
+end

data/definitions/checks/foreman_tasks/invalid/check_planning_state.rb

@@ -0,0 +1,20 @@
+module Checks::ForemanTasks
+  module Invalid
+    class CheckPlanningState < ForemanMaintain::Check
+      metadata do
+        label :check_foreman_tasks_in_planning_state
+        for_feature :foreman_tasks
+        tags :pre_upgrade
+        description 'Check for tasks in planning state'
+      end
+
+      def run
+        # Check and delete 'all tasks in planning state'
+        tasks_in_planning_count = feature(:foreman_tasks).count(:planning)
+        assert(tasks_in_planning_count <= 0,
+               "Found #{tasks_in_planning_count} task(s) in planning state",
+               :next_steps => Procedures::ForemanTasks::Delete.new(:state => :planning))
+      end
+    end
+  end
+end

data/definitions/checks/foreman_tasks/not_paused.rb

@@ -0,0 +1,29 @@
+module Checks::ForemanTasks
+  class NotPaused < ForemanMaintain::Check
+    metadata do
+      for_feature :foreman_tasks
+      description 'check for paused tasks'
+      tags :default
+    end
+
+    def run
+      paused_tasks_count = feature(:foreman_tasks).paused_tasks_count(ignored_tasks)
+      assert(paused_tasks_count == 0,
+             "There are currently #{paused_tasks_count} paused tasks in the system",
+             :next_steps =>
+               [Procedures::ForemanTasks::Resume.new,
+                Procedures::ForemanTasks::UiInvestigate.new('search_query' => scoped_search_query)])
+    end
+
+    # Note: this is for UI link generation only: we are not using scoped search for querying
+    # the tasks itself as we use direct SQL instead
+    def scoped_search_query
+      "state = paused AND label !^(#{ignored_tasks.join(' ')})"
+    end
+
+    def ignored_tasks
+      %w[Actions::Candlepin::ListenOnCandlepinEvents
+         Actions::Katello::EventQueue::Monitor]
+    end
+  end
+end

data/definitions/checks/foreman_tasks/not_running.rb

@@ -0,0 +1,14 @@
+module Checks::ForemanTasks
+  class NotRunning < ForemanMaintain::Check
+    metadata do
+      for_feature :foreman_tasks
+      description 'check for running tasks'
+      tags :pre_upgrade
+    end
+
+    def run
+      assert(feature(:foreman_tasks).running_tasks_count == 0,
+             'There are actively running tasks in the system')
+    end
+  end
+end

data/definitions/checks/sync_plans/with_disabled_status.rb

@@ -0,0 +1,18 @@
+module Checks::SyncPlans
+  class WithDisabledStatus < ForemanMaintain::Check
+    include ForemanMaintain::Concerns::Hammer
+
+    metadata do
+      for_feature :sync_plans
+      description 'check for disabled sync plans'
+      tags :post_upgrade
+    end
+
+    def run
+      disabled_plans_count = feature(:sync_plans).disabled_plans_count
+      assert(disabled_plans_count == 0,
+             "There are #{disabled_plans_count} disabled sync plans which needs to be enabled",
+             :next_steps => Procedures::SyncPlans::Enable.new)
+    end
+  end
+end

data/definitions/checks/sync_plans/with_enabled_status.rb

@@ -0,0 +1,18 @@
+module Checks::SyncPlans
+  class WithEnabledStatus < ForemanMaintain::Check
+    include ForemanMaintain::Concerns::Hammer
+
+    metadata do
+      for_feature :sync_plans
+      description 'check for enabled sync plans'
+      tags :pre_upgrade
+    end
+
+    def run
+      active_sync_plans_count = feature(:sync_plans).active_sync_plans_count
+      assert(active_sync_plans_count == 0,
+             "There are total #{active_sync_plans_count} active sync plans in the system",
+             :next_steps => Procedures::SyncPlans::Disable.new)
+    end
+  end
+end

data/definitions/checks/system_registration.rb

@@ -0,0 +1,31 @@
+class Checks::SystemRegistration < ForemanMaintain::Check
+  metadata do
+    label :verify_self_registration
+    description 'Check whether system is self-registered or not'
+    tags :default
+
+    confine do
+      file_exists?('/etc/rhsm/rhsm.conf')
+    end
+  end
+
+  def run
+    if system_is_self_registerd?
+      raise ForemanMaintain::Error::Warn, 'System is self registered'
+    else
+      puts 'System is not self registered'
+    end
+  end
+
+  def system_is_self_registerd?
+    rhsm_hostname.casecmp(hostname).zero?
+  end
+
+  def rhsm_hostname
+    execute("grep '\\bhostname\\b' < #{rhsm_conf_file}  | grep -v '^#'").sub(/.*?=/, '').strip
+  end
+
+  def rhsm_conf_file
+    '/etc/rhsm/rhsm.conf'
+  end
+end