foreman_maintain 0.1.6 → 0.2.0

data/definitions/procedures/foreman_tasks/fetch_tasks_status.rb

@@ -4,6 +4,7 @@ module Procedures::ForemanTasks
       for_feature :foreman_tasks
       description 'Fetch tasks status and wait till they finish'
       param :state, "Specify state of tasks. Either 'running' or 'paused'", :required => true
+      advanced_run false
     end
 
     def run

data/definitions/procedures/hammer_setup.rb

@@ -1,50 +1,15 @@
 class Procedures::HammerSetup < ForemanMaintain::Procedure
   metadata do
     description 'Setup hammer'
+    for_feature :hammer
   end
 
   def run
-    setup_from_default || setup_from_answers
-    puts "New settings saved into #{hammer.config_file}"
-    hammer.run_command('architecture list') # if not setup properly, an error will be risen
+    result = feature(:hammer).setup_admin_access
+    logger.info 'Hammer was configured successfully.' if result
   end
 
   def necessary?
-    !hammer.ready?
-  end
-
-  private
-
-  def setup_from_default
-    used_default_file = hammer.setup_from_default
-    if used_default_file
-      puts "Using defaults from #{used_default_file}"
-      true
-    end
-  end
-
-  def setup_from_answers
-    loop do
-      username, password = ask_for_credentials
-      break if username.nil?
-      if hammer.setup_from_answers(username, password)
-        return true
-      else
-        puts 'Invalid credentials'
-      end
-    end
-  end
-
-  def ask_for_credentials
-    username = ask('Hammer username [admin]:')
-    return if username.nil?
-    username = 'admin' if username.empty?
-    password = ask('Hammer password:', :password => true)
-    return if password.nil?
-    [username.strip, password.strip]
-  end
-
-  def hammer
-    ForemanMaintain::Utils::Hammer.instance
+    !feature(:hammer).check_connection
   end
 end

data/definitions/procedures/installer/upgrade.rb

@@ -1,27 +1,7 @@
 module Procedures::Installer
   class Upgrade < ForemanMaintain::Procedure
     def run
-      execute!("LANG=en_US.utf-8 #{installer_command} #{upgrade_command?}", :interactive => true)
-    end
-
-    private
-
-    def upgrade_command?
-      if package_version('satellite-installer') || package_version('katello-installer')
-        '--upgrade'
-      end
-    end
-
-    def installer_command
-      if feature(:downstream)
-        if feature(:downstream).current_minor_version <= '6.1'
-          'katello-installer'
-        else
-          'satellite-installer'
-        end
-      else
-        'foreman-installer'
-      end
+      feature(:installer).upgrade(:interactive => true)
     end
   end
 end

data/definitions/procedures/repositories/setup.rb

@@ -2,10 +2,6 @@ module Procedures::Repositories
   class Setup < ForemanMaintain::Procedure
     metadata do
       description 'Setup repositories'
-      preparation_steps do
-        Procedures::Packages::Install.new(:packages => [ForemanMaintain::Utils::Facter.package])
-      end
-
       confine do
         feature(:downstream) || feature(:upstream)
       end

data/definitions/procedures/service/base.rb

@@ -0,0 +1,31 @@
+module Procedures
+  module Service
+    class Base < ForemanMaintain::Procedure
+      metadata do
+        advanced_run false
+      end
+
+      def self.common_params(context)
+        context.instance_eval do
+          param :only, 'A comma-separated list of services to include', :array => true
+          param :exclude, 'A comma-separated list of services to skip', :array => true
+        end
+      end
+
+      def run_service_action(action, options)
+        action_noun = feature(:service).action_noun(action).capitalize
+        puts "#{action_noun} the following service(s):\n"
+        services = feature(:service).filtered_services(options)
+        feature(:service).list_services(services)
+
+        with_spinner('') do |spinner|
+          feature(:service).handle_services(spinner, action, options)
+        end
+      end
+
+      def common_options
+        { :only => @only, :exclude => @exclude }
+      end
+    end
+  end
+end

data/definitions/procedures/service/disable.rb

@@ -0,0 +1,14 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Disable < Base
+    metadata do
+      description 'Disable applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      run_service_action('disable', common_options)
+    end
+  end
+end

data/definitions/procedures/service/enable.rb

@@ -0,0 +1,14 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Enable < Base
+    metadata do
+      description 'Enable applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      run_service_action('enable', common_options)
+    end
+  end
+end

data/definitions/procedures/service/list.rb

@@ -0,0 +1,26 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class List < Base
+    metadata do
+      description 'List applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      services = feature(:service).filtered_services(common_options)
+      unit_files = unit_files_list(services)
+      puts unit_files + "\n"
+    end
+
+    def unit_files_list(services)
+      if systemd_installed?
+        regex = services.map { |service| "^#{service}.service" }.join('\|')
+        execute("systemctl list-unit-files | grep '#{regex}'")
+      else
+        regex = services.map { |service| "^#{service} " }.join('\|')
+        execute("chkconfig --list 2>&1 | grep '#{regex}'")
+      end
+    end
+  end
+end

data/definitions/procedures/service/restart.rb

@@ -0,0 +1,49 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Restart < Base
+    metadata do
+      description 'Restart applicable services'
+      Base.common_params(self)
+      param :wait_for_hammer_ping,
+            'Wait for hammer ping to return successfully before terminating'
+    end
+
+    RETRIES_FOR_SERVICES_RESTART = 5
+    PING_RETRY_INTERVAL = 30
+
+    def run
+      run_service_action('stop', common_options)
+      run_service_action('start', common_options)
+      hammer_ping_retry if @wait_for_hammer_ping
+    end
+
+    def hammer_ping_retry
+      with_spinner('Checking hammer ping') do |spinner|
+        RETRIES_FOR_SERVICES_RESTART.times do |retry_count|
+          spinner.update retry_message(retry_count)
+          result = feature(:hammer).hammer_ping_cmd
+          if result[:success]
+            spinner.update 'Hammer ping returned successfully!'
+            break
+          elsif retry_count < (RETRIES_FOR_SERVICES_RESTART - 1)
+            apply_sleep_before_retry(spinner, result)
+          end
+        end
+      end
+    rescue StandardError => e
+      logger.error e.message
+    end
+
+    def retry_message(retry_count)
+      "Try #{retry_count + 1}/#{RETRIES_FOR_SERVICES_RESTART}: " \
+      'checking status of hammer ping'
+    end
+
+    def apply_sleep_before_retry(spinner, result)
+      puts "\n#{result[:message]}"
+      spinner.update "Waiting #{PING_RETRY_INTERVAL} seconds before retry."
+      sleep PING_RETRY_INTERVAL
+    end
+  end
+end

data/definitions/procedures/service/start.rb

@@ -0,0 +1,14 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Start < Base
+    metadata do
+      description 'Start applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      run_service_action('start', common_options)
+    end
+  end
+end

data/definitions/procedures/service/status.rb

@@ -0,0 +1,14 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Status < Base
+    metadata do
+      description 'Get status of applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      run_service_action('status', common_options)
+    end
+  end
+end

data/definitions/procedures/service/stop.rb

@@ -0,0 +1,14 @@
+require 'procedures/service/base'
+
+module Procedures::Service
+  class Stop < Base
+    metadata do
+      description 'Stop applicable services'
+      Base.common_params(self)
+    end
+
+    def run
+      run_service_action('stop', common_options)
+    end
+  end
+end

data/definitions/scenarios/backup.rb

@@ -0,0 +1,242 @@
+module ForemanMaintain::Scenarios
+  class Backup < ForemanMaintain::Scenario
+    metadata do
+      description 'Backup'
+      manual_detection
+      tags :backup
+      run_strategy :fail_fast
+      param :strategy, 'Backup strategy. One of [:online, :offline, :snapshot]',
+            :required => true
+      param :backup_dir, 'Directory where to backup to', :required => true
+      param :mount_dir, 'Snapshot mount directory'
+      param :include_db_dumps, 'Include dumps of local dbs as part of offline'
+      param :preserve_dir, 'Directory where to backup to'
+      param :incremental_dir, 'Changes since specified backup only'
+      param :proxy_features, 'List of proxy features to backup (default: all)', :array => true
+      param :snapshot_mount_dir, 'Snapshot mount directory'
+      param :snapshot_block_size, 'Snapshot block size'
+      param :skip_pulp_content, 'Skip Pulp content during backup'
+      param :tar_volume_size, 'Size of tar volume (indicates splitting)'
+    end
+
+    # rubocop:disable  Metrics/MethodLength
+    def compose
+      check_valid_startegy
+      safety_confirmation
+      accessibility_confirmation
+      prepare_directory
+      logical_volume_confirmation
+      add_step_with_context(Procedures::Backup::Metadata)
+      add_step_with_context(Procedures::Backup::ConfigFiles)
+
+      case strategy
+      when :online
+        add_online_backup_steps
+      when :offline
+        add_offline_backup_steps
+      when :snapshot
+        add_snaphot_backup_steps
+      end
+      add_step_with_context(Procedures::Backup::CompressData)
+    end
+    # rubocop:enable  Metrics/MethodLength
+
+    # rubocop:disable  Metrics/MethodLength
+    def set_context_mapping
+      context.map(:backup_dir,
+                  Checks::Backup::DirectoryReady => :backup_dir,
+                  Procedures::Backup::PrepareDirectory => :backup_dir,
+                  Procedures::Backup::Metadata => :backup_dir,
+                  Procedures::Backup::ConfigFiles => :backup_dir,
+                  Procedures::Backup::CompressData => :backup_dir,
+                  Procedures::Backup::Pulp => :backup_dir,
+                  Procedures::Backup::Online::Mongo => :backup_dir,
+                  Procedures::Backup::Online::PgGlobalObjects => :backup_dir,
+                  Procedures::Backup::Online::CandlepinDB => :backup_dir,
+                  Procedures::Backup::Online::ForemanDB => :backup_dir,
+                  Procedures::Backup::Offline::CandlepinDB => :backup_dir,
+                  Procedures::Backup::Offline::ForemanDB => :backup_dir,
+                  Procedures::Backup::Offline::Mongo => :backup_dir,
+                  Procedures::Backup::Snapshot::LogicalVolumeConfirmation => :backup_dir,
+                  Procedures::Backup::Snapshot::MountCandlepinDB => :backup_dir,
+                  Procedures::Backup::Snapshot::MountForemanDB => :backup_dir,
+                  Procedures::Backup::Snapshot::MountMongo => :backup_dir)
+      context.map(:preserve_dir,
+                  Checks::Backup::DirectoryReady => :preserve_dir,
+                  Procedures::Backup::PrepareDirectory => :preserve_dir)
+      context.map(:incremental_dir,
+                  Procedures::Backup::PrepareDirectory => :incremental_dir,
+                  Procedures::Backup::Metadata => :incremental_dir)
+      context.map(:proxy_features,
+                  Procedures::Backup::ConfigFiles => :proxy_features)
+      context.map(:snapshot_mount_dir,
+                  Procedures::Backup::Snapshot::PrepareMount => :mount_dir,
+                  Procedures::Backup::Snapshot::MountMongo => :mount_dir,
+                  Procedures::Backup::Snapshot::MountPulp => :mount_dir,
+                  Procedures::Backup::Snapshot::CleanMount => :mount_dir,
+                  Procedures::Backup::Snapshot::MountCandlepinDB => :mount_dir,
+                  Procedures::Backup::Snapshot::MountForemanDB => :mount_dir,
+                  Procedures::Backup::Offline::Mongo => :mount_dir,
+                  Procedures::Backup::Pulp => :mount_dir,
+                  Procedures::Backup::Offline::CandlepinDB => :mount_dir,
+                  Procedures::Backup::Offline::ForemanDB => :mount_dir)
+      context.map(:snapshot_block_size,
+                  Procedures::Backup::Snapshot::MountMongo => :block_size,
+                  Procedures::Backup::Snapshot::MountPulp => :block_size,
+                  Procedures::Backup::Snapshot::MountForemanDB => :block_size,
+                  Procedures::Backup::Snapshot::MountCandlepinDB => :block_size)
+      context.map(:skip_pulp_content,
+                  Procedures::Backup::Pulp => :skip,
+                  Procedures::Backup::Snapshot::LogicalVolumeConfirmation => :skip_pulp,
+                  Procedures::Backup::Snapshot::MountPulp => :skip)
+      context.map(:tar_volume_size,
+                  Procedures::Backup::Pulp => :tar_volume_size)
+    end
+    # rubocop:enable  Metrics/MethodLength
+
+    private
+
+    def prepare_directory
+      add_steps_with_context(
+        Procedures::Backup::PrepareDirectory,
+        Checks::Backup::DirectoryReady
+      )
+    end
+
+    def logical_volume_confirmation
+      if strategy == :snapshot
+        add_step_with_context(Procedures::Backup::Snapshot::LogicalVolumeConfirmation)
+      end
+    end
+
+    def accessibility_confirmation
+      if [:offline, :snapshot].include?(strategy)
+        add_step_with_context(Procedures::Backup::AccessibilityConfirmation)
+      end
+    end
+
+    def safety_confirmation
+      if online_backup? || include_db_dumps?
+        add_step_with_context(Procedures::Backup::Online::SafetyConfirmation)
+      end
+    end
+
+    def check_valid_startegy
+      unless [:online, :offline, :snapshot].include? strategy
+        raise ArgumentError, "Unsupported strategy '#{strategy}'"
+      end
+    end
+
+    def add_offline_backup_steps
+      include_dumps if include_db_dumps?
+      add_steps_with_context(
+        Procedures::MaintenanceMode::Enable,
+        Procedures::Service::Stop,
+        Procedures::Backup::Pulp,
+        Procedures::Backup::Offline::Mongo,
+        Procedures::Backup::Offline::CandlepinDB,
+        Procedures::Backup::Offline::ForemanDB,
+        Procedures::Service::Start,
+        Procedures::MaintenanceMode::Disable
+      )
+    end
+
+    def include_dumps
+      if feature(:instance).postgresql_local?
+        add_step_with_context(Procedures::Backup::Online::PgGlobalObjects)
+      end
+      if feature(:instance).database_local?(:candlepin_database)
+        add_step_with_context(Procedures::Backup::Online::CandlepinDB)
+      end
+      if feature(:instance).database_local?(:foreman_database)
+        add_step_with_context(Procedures::Backup::Online::ForemanDB)
+      end
+      if feature(:instance).database_local?(:mongo)
+        add_step_with_context(Procedures::Backup::Online::Mongo)
+      end
+    end
+
+    # rubocop:disable  Metrics/MethodLength
+    def add_snaphot_backup_steps
+      add_steps_with_context(
+        Procedures::Backup::Snapshot::PrepareMount,
+        Procedures::MaintenanceMode::Enable,
+        Procedures::Service::Stop,
+        Procedures::Backup::Snapshot::MountMongo,
+        Procedures::Backup::Snapshot::MountPulp,
+        Procedures::Backup::Snapshot::MountCandlepinDB,
+        Procedures::Backup::Snapshot::MountForemanDB,
+        Procedures::Service::Start,
+        Procedures::MaintenanceMode::Disable,
+        Procedures::Backup::Pulp
+      )
+      if feature(:instance).database_local?(:candlepin_database)
+        add_step_with_context(Procedures::Backup::Offline::CandlepinDB)
+      end
+      if feature(:instance).database_local?(:foreman_database)
+        add_step_with_context(Procedures::Backup::Offline::ForemanDB)
+      end
+      if feature(:instance).database_local?(:mongo)
+        add_step_with_context(Procedures::Backup::Offline::Mongo)
+      end
+      add_step_with_context(Procedures::Backup::Snapshot::CleanMount)
+    end
+    # rubocop:enable  Metrics/MethodLength
+
+    def add_online_backup_steps
+      add_step_with_context(Procedures::Backup::Pulp, :ensure_unchanged => true)
+      add_steps_with_context(
+        Procedures::Backup::Online::Mongo,
+        Procedures::Backup::Online::PgGlobalObjects,
+        Procedures::Backup::Online::CandlepinDB,
+        Procedures::Backup::Online::ForemanDB
+      )
+    end
+
+    def strategy
+      context.get(:strategy)
+    end
+
+    def include_db_dumps?
+      !!context.get(:include_db_dumps)
+    end
+
+    def online_backup?
+      strategy == :online
+    end
+  end
+
+  class BackupRescueCleanup < ForemanMaintain::Scenario
+    metadata do
+      description 'Failed backup cleanup'
+      manual_detection
+      run_strategy :fail_slow
+      tags :backup
+      param :backup_dir, 'Directory where to backup to', :required => true
+      param :mount_dir, 'Snapshot mount directory'
+      param :preserve_dir, 'Directory where to backup to'
+    end
+
+    def compose
+      add_step_with_context(Procedures::Service::Start) if strategy != :online
+      add_step_with_context(Procedures::MaintenanceMode::Disable) if strategy != :online
+      add_step_with_context(Procedures::Backup::Snapshot::CleanMount) if strategy == :snapshot
+      add_step_with_context(Procedures::Backup::Clean)
+    end
+
+    def set_context_mapping
+      context.map(:snapshot_mount_dir,
+                  Procedures::Backup::Snapshot::CleanMount => :mount_dir)
+      context.map(:backup_dir,
+                  Procedures::Backup::Clean => :backup_dir)
+      context.map(:preserve_dir,
+                  Procedures::Backup::Clean => :preserve_dir)
+    end
+
+    private
+
+    def strategy
+      context.get(:strategy)
+    end
+  end
+end