foreman_maintain 0.1.6 → 0.2.0

data/lib/foreman_maintain/cli/base.rb

@@ -34,17 +34,16 @@ module ForemanMaintain
       end
 
       def reporter
-        @reporter ||= ForemanMaintain::Reporter::CLIReporter.new(STDOUT,
-                                                                 STDIN,
-                                                                 :assumeyes => assumeyes?)
+        @reporter ||= ForemanMaintain.reporter
       end
 
-      def run_scenario(scenarios)
+      def run_scenario(scenarios, rescue_scenario = nil)
         @runner ||=
           ForemanMaintain::Runner.new(reporter, scenarios,
-                                      :assumeyes => assumeyes?,
-                                      :whitelist => whitelist || [],
-                                      :force => force?)
+                                      :assumeyes => option_wrapper('assumeyes?'),
+                                      :whitelist => option_wrapper('whitelist') || [],
+                                      :force => option_wrapper('force?'),
+                                      :rescue_scenario => rescue_scenario)
         runner.run
       end
 
@@ -101,7 +100,9 @@ module ForemanMaintain
         delete_duplicate_assumeyes_if_any
 
         option ['-y', '--assumeyes'], :flag,
-               'Automatically answer yes for all questions'
+               'Automatically answer yes for all questions' do |assume|
+          ForemanMaintain.reporter.assumeyes = assume
+        end
 
         option(['-w', '--whitelist'], 'whitelist',
                'Comma-separated list of labels of steps to be skipped') do |whitelist|
@@ -113,9 +114,18 @@ module ForemanMaintain
                'Force steps that would be skipped as they were already run'
       end
 
+      def self.service_options
+        option '--exclude', 'EXCLUDE', 'A comma-separated list of services to skip'
+        option '--only', 'ONLY', 'A comma-separated list of services to include'
+      end
+
       def self.delete_duplicate_assumeyes_if_any
         declared_options.delete_if { |opt| opt.handles?('--assumeyes') }
       end
+
+      def option_wrapper(option)
+        respond_to?(option.to_sym) ? send(option) : false
+      end
     end
   end
 end

data/lib/foreman_maintain/cli/service_command.rb

@@ -0,0 +1,112 @@
+module ForemanMaintain
+  module Cli
+    class ServiceCommand < Base
+      extend Concerns::Finders
+
+      subcommand 'start', 'Start applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceStart.new(
+            :only => only,
+            :exclude => exclude
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'stop', 'Stop applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceStop.new(
+            :only => only,
+            :exclude => exclude
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'restart', 'Restart applicable services' do
+        service_options
+        if feature(:katello)
+          option ['-p', '--wait-for-hammer-ping'], :flag,
+                 'Wait for hammer ping to return successfully before terminating'
+        end
+
+        def execute
+          scenario = Scenarios::ServiceRestart.new(
+            :only => only,
+            :exclude => exclude,
+            :wait_for_hammer_ping => option_wrapper('wait_for_hammer_ping?')
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'status', 'Get statuses of applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceStatus.new(
+            :only => only,
+            :exclude => exclude
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'list', 'List applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceList.new(
+            :only => only,
+            :exclude => exclude,
+            :action => 'status'
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'enable', 'Enable applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceEnable.new(
+            :only => only,
+            :exclude => exclude, :action => 'status'
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+
+      subcommand 'disable', 'Disable applicable services' do
+        service_options
+
+        def execute
+          scenario = Scenarios::ServiceDisable.new(
+            :only => only,
+            :exclude => exclude,
+            :action => 'status'
+          )
+
+          run_scenario(scenario)
+          exit runner.exit_code
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/transform_clamp_options.rb

@@ -26,7 +26,7 @@ module ForemanMaintain
         private
 
         def option_sym(option)
-          option = option.switches.first[2..-1].to_s
+          option = underscorize(option.switches.first[2..-1].to_s)
           option.to_sym unless option.empty?
         end
 

data/lib/foreman_maintain/concerns/base_database.rb

@@ -1,10 +1,24 @@
 module ForemanMaintain
   module Concerns
     module BaseDatabase
+      def data_dir
+        '/var/lib/pgsql/data/'
+      end
+
       def configuration
         raise NotImplementedError
       end
 
+      def config_files
+        [
+          '/etc/systemd/system/postgresql.service'
+        ]
+      end
+
+      def local?(config = configuration)
+        ['localhost', '127.0.0.1', `hostname`.strip].include? config['host']
+      end
+
       def query(sql, config = configuration)
         parse_csv(query_csv(sql, config))
       end
@@ -15,14 +29,18 @@ module ForemanMaintain
 
       def psql(query, config = configuration)
         if ping(config)
-          execute(psql_command(config), :stdin => query)
+          execute(psql_command(config),
+                  :stdin => query,
+                  :hidden_patterns => [config['password']])
         else
           raise_service_error
         end
       end
 
       def ping(config = configuration)
-        execute?(psql_command(config), :stdin => 'SELECT 1 as ping')
+        execute?(psql_command(config),
+                 :stdin => 'SELECT 1 as ping',
+                 :hidden_patterns => [config['password']])
       end
 
       def backup_file_path(config = configuration)
@@ -30,19 +48,41 @@ module ForemanMaintain
         "#{backup_dir}/#{dump_file_name}.bz2"
       end
 
+      def dump_db(file, config = configuration)
+        execute!(dump_command(config) + " > #{file}", :hidden_patterns => [config['password']])
+      end
+
+      def backup_local(backup_file, extra_tar_options = {})
+        dir = extra_tar_options.fetch(:data_dir, data_dir)
+        FileUtils.cd(dir) do
+          tar_options = {
+            :archive => backup_file,
+            :command => 'create',
+            :transform => 's,^,var/lib/pgsql/data/,S'
+          }.merge(extra_tar_options)
+          feature(:tar).run(tar_options)
+        end
+      end
+
+      # TODO: refactor to use dump_db
       def backup_db_command(file_path, config = configuration)
         pg_dump_cmd = "pg_dump -Fc #{config['database']}"
         "runuser - postgres -c '#{pg_dump_cmd}' | bzip2 -9 > #{file_path}"
       end
 
+      # TODO: remove the backup file path tools from here. Lib Utils::Backup?
       def backup_dir
         @backup_dir ||= File.expand_path(ForemanMaintain.config.db_backup_dir)
       end
 
+      def backup_global_objects(file)
+        execute!("runuser - postgres -c 'pg_dumpall -g > #{file}'")
+      end
+
       def perform_backup(config = configuration)
         file_path = backup_file_path(config)
         backup_cmd = backup_db_command(file_path, config)
-        execute!(backup_cmd)
+        execute!(backup_cmd, :hidden_patterns => [config['password']])
         puts "\n Note: Database backup file path - #{file_path}"
         puts "\n In case of any exception, use above dump file to restore DB."
       end
@@ -68,14 +108,26 @@ module ForemanMaintain
         end
       end
 
+      def find_base_directory(directory)
+        find_dir_containing_file(directory, 'postgresql.conf')
+      end
+
       private
 
-      def psql_command(config)
+      def base_command(config, command = 'psql')
         "PGPASSWORD='#{config[%(password)]}' "\
-        "psql -d #{config['database']} -h #{config['host'] || 'localhost'} "\
+        "#{command} -h #{config['host'] || 'localhost'} "\
         " -p #{config['port'] || '5432'} -U #{config['username']}"
       end
 
+      def psql_command(config)
+        base_command(config, 'psql') + " -d #{config['database']}"
+      end
+
+      def dump_command(config)
+        base_command(config, 'pg_dump') + " -Fc #{config['database']}"
+      end
+
       def raise_service_error
         raise Error::Fail, 'Please check whether database service is up & running state.'
       end

data/lib/foreman_maintain/concerns/hammer.rb

@@ -6,15 +6,6 @@ module ForemanMaintain
           preparation_steps { Procedures::HammerSetup.new }
         end
       end
-
-      # Run a hammer command, examples:
-      # hammer('host list')
-      def hammer(args)
-        Utils::Hammer.instance.run_command(args)
-      end
-
-      # TODO: method for specifying that the check that includes this method
-      # requires hammer to be setup
     end
   end
 end

data/lib/foreman_maintain/concerns/metadata.rb

@@ -203,7 +203,9 @@ module ForemanMaintain
         def preparation_steps(recursion_depth = 0, trace = [])
           raise "Too many dependent steps #{trace}" if recursion_depth > MAX_PREPARATION_STEPS_DEPTH
           return @preparation_steps if defined?(@preparation_steps)
-          preparation_steps = metadata[:preparation_steps_blocks].map(&:call)
+          preparation_steps = metadata[:preparation_steps_blocks].map do |block|
+            instance_exec(&block)
+          end.flatten.compact
           preparation_steps.each { |step| raise ArgumentError unless step.is_a?(Executable) }
           all_preparation_steps = []
           preparation_steps.each do |step|

data/lib/foreman_maintain/concerns/reporter.rb

@@ -0,0 +1,12 @@
+module ForemanMaintain
+  module Concerns
+    module Reporter
+      extend Forwardable
+      def_delegators :reporter, :with_spinner, :puts, :print, :ask, :assumeyes?
+
+      def reporter
+        ForemanMaintain.reporter
+      end
+    end
+  end
+end

data/lib/foreman_maintain/concerns/system_helpers.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'csv'
+require 'find'
 require 'shellwords'
 
 module ForemanMaintain
@@ -26,6 +27,19 @@ module ForemanMaintain
         end
       end
 
+      def systemd_installed?
+        File.exist?('/usr/bin/systemctl')
+      end
+
+      def service_exists?(service)
+        if systemd_installed?
+          systemd = execute("systemctl is-enabled #{service} 2>&1 | tail -1").strip
+          systemd == 'enabled' || systemd == 'disabled'
+        else
+          File.exist?("/etc/init.d/#{service}")
+        end
+      end
+
       def check_min_version(name, minimal_version)
         current_version = package_version(name)
         if current_version
@@ -38,8 +52,8 @@ module ForemanMaintain
           (execute('rpm -q foreman') =~ /sat.noarch/)
       end
 
-      def execute?(command, input = nil)
-        execute(command, :stdin => input)
+      def execute?(command, options = {})
+        execute(command, options)
         $CHILD_STATUS.success?
       end
 
@@ -153,6 +167,35 @@ module ForemanMaintain
         result = execute(cmd).strip
         result.split(/\n/)
       end
+
+      def directory_empty?(dir)
+        Dir.entries(dir).size <= 2
+      end
+
+      def get_lv_info(dir)
+        execute("findmnt -n --target #{dir} -o SOURCE,FSTYPE").split
+      end
+
+      def create_lv_snapshot(name, block_size, path)
+        execute!("lvcreate -n#{name} -L#{block_size} -s #{path}")
+      end
+
+      def get_lv_path(lv_name)
+        execute("lvs --noheadings -o lv_path -S lv_name=#{lv_name}").strip
+      end
+
+      def local_psql_database?
+        (feature(:foreman_database) && feature(:foreman_database).local?) ||
+          (feature(:candlepin_database) && feature(:candlepin_database).local?)
+      end
+
+      def find_dir_containing_file(directory, target)
+        result = nil
+        Find.find(directory) do |path|
+          result = File.dirname(path) if File.basename(path) == target
+        end
+        result
+      end
     end
   end
 end

data/lib/foreman_maintain/detector.rb

@@ -58,7 +58,9 @@ module ForemanMaintain
     def available_scenarios(filter_conditions = nil)
       unless @available_scenarios
         ensure_features_detected
-        @available_scenarios = @scenarios.select(&:present?).map(&:new)
+        @available_scenarios = @scenarios.select do |scenario|
+          scenario.present? && scenario.autodetect?
+        end.map(&:new)
       end
       filter(@available_scenarios, filter_conditions)
     end
@@ -104,7 +106,6 @@ module ForemanMaintain
       ret
     end
 
-    # rubocop:disable Metrics/AbcSize
     def detect_feature(label)
       return @features_by_label[label] if @features_by_label.key?(label)
       return unless autodetect_features.key?(label)
@@ -122,7 +123,6 @@ module ForemanMaintain
       end
       present_feature
     end
-    # rubocop:enable Metrics/AbcSize
 
     def autodetect_features
       @autodetect_features ||= Feature.sub_classes.reduce({}) do |hash, feature_class|

data/lib/foreman_maintain/error.rb

@@ -6,6 +6,12 @@ module ForemanMaintain
     class Warn < StandardError
     end
 
+    class Skip < StandardError
+    end
+
+    class Abort < StandardError
+    end
+
     class MultipleBeforeDetected < StandardError
       def initialize(step_labels)
         @step_labels = step_labels
@@ -38,5 +44,11 @@ module ForemanMaintain
     # Error caused by incorrect usage, usually connected to passed CLI options
     class UsageError < StandardError
     end
+
+    class Validation < StandardError
+    end
+  end
+
+  class HammerConfigurationError < StandardError
   end
 end