foreman_maintain 0.1.6 → 0.2.0

data/definitions/features/sync_plans.rb

@@ -41,7 +41,7 @@ class Features::SyncPlans < ForemanMaintain::Feature
   def update_records(ids, enabled)
     updated_record_ids = []
     ids.each do |sp_id|
-      result = hammer("sync-plan update --id #{sp_id} --enabled #{enabled}")
+      result = feature(:hammer).run("sync-plan update --id #{sp_id} --enabled #{enabled}")
       if result.include?('Sync plan updated')
         updated_record_ids << sp_id
       else

data/definitions/features/tar.rb

@@ -0,0 +1,69 @@
+class Features::Tar < ForemanMaintain::Feature
+  metadata do
+    label :tar
+    preparation_steps { Procedures::Packages::Install.new(:packages => %w[tar]) }
+  end
+
+  # Run system tar
+  # @param [Hash] options tar configuration
+  # @option options [String] :archive archive name
+  # @option options [String] :command ('create') tar operation command
+  # @option options [Array] :exclude dirs or files to exclude
+  # @option options [String] :listed_incremental .snar file to do incremental backup
+  # @option options [String] :transform sed expression to transform the filenames
+  # @option options [String] :volume_size size of tar volume
+  #                           (will try to split the archive when set)
+  # @option options [String] :files (*) files to operate on
+  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  def run(options = {})
+    volume_size = options.fetch(:volume_size, nil)
+    validate_volume_size(volume_size) unless volume_size.nil?
+
+    tar_command = ['tar']
+    tar_command << '--selinux'
+    tar_command << "--#{options.fetch(:command, 'create')}"
+    tar_command << "--file=#{options.fetch(:archive)}"
+
+    if volume_size
+      split_tar_script = default_split_tar_script
+      tar_command << "--tape-length=#{volume_size}"
+      tar_command << "--new-volume-script=#{split_tar_script}"
+    end
+
+    exclude = options.fetch(:exclude, [])
+    exclude.each do |ex|
+      tar_command << "--exclude=#{ex}"
+    end
+
+    snar_file = options.fetch(:listed_incremental, nil)
+    tar_command << "--listed-incremental=#{snar_file}" if snar_file
+
+    trans = options.fetch(:transform, nil)
+    tar_command << "--transform '#{trans}'" if trans
+
+    tar_command << '-S'
+    tar_command << options.fetch(:files, '*')
+
+    execute!(tar_command.join(' '))
+  end
+  # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+  def validate_volume_size(size)
+    if size.nil? || size !~ /^\d+[bBcGKkMPTw]?$/
+      raise ForemanMaintain::Error::Validation,
+            "Please specify size according to 'tar --tape-length' format."
+    end
+    true
+  end
+
+  private
+
+  def default_split_tar_script
+    utils_path = File.expand_path('../../../bin', __FILE__)
+    split_tar_script = File.join(utils_path, 'foreman-maintain-rotate-tar')
+    unless File.executable?(split_tar_script)
+      raise ForemanMaintain::Error::Fail, "Script #{split_tar_script} is not executable"
+    end
+    split_tar_script
+  end
+end

data/definitions/procedures/backup/accessibility_confirmation.rb

@@ -0,0 +1,14 @@
+module Procedures::Backup
+  class AccessibilityConfirmation < ForemanMaintain::Procedure
+    metadata do
+      description 'Confirm turning off services is allowed'
+      tags :backup
+    end
+
+    def run
+      answer = ask_decision("WARNING: This script will stop your services.\n\n" \
+         'Do you want to proceed?', 'y(yes), q(quit)')
+      abort! unless answer == :yes
+    end
+  end
+end

data/definitions/procedures/backup/clean.rb

@@ -0,0 +1,16 @@
+module Procedures::Backup
+  class Clean < ForemanMaintain::Procedure
+    metadata do
+      description 'Clean up backup directory'
+      tags :backup
+      param :backup_dir, 'Directory where to backup to', :required => true
+      param :preserve_dir, 'Directory where to backup to'
+    end
+
+    def run
+      skip('Backup directory will be preserved') if @preserve_dir
+      FileUtils.rm_rf @backup_dir
+      logger.info("Backup directory #{@backup_dir} was removed.")
+    end
+  end
+end

data/definitions/procedures/backup/compress_data.rb

@@ -0,0 +1,26 @@
+module Procedures::Backup
+  class CompressData < ForemanMaintain::Procedure
+    metadata do
+      description 'Compress backup data to save space'
+      tags :backup
+      param :backup_dir, 'Directory where to backup to', :required => true
+    end
+
+    def run
+      compress_file('pgsql_data.tar', 'Postgress DB')
+      compress_file('mongo_data.tar', 'Mongo DB')
+    end
+
+    private
+
+    def compress_file(archive, archive_name)
+      data_tar = File.join(@backup_dir, archive)
+      if File.exist?(data_tar)
+        with_spinner("Compressing backup of #{archive_name}") do
+          gzip = spawn('gzip', data_tar, '-f')
+          Process.wait(gzip)
+        end
+      end
+    end
+  end
+end

data/definitions/procedures/backup/config_files.rb

@@ -0,0 +1,36 @@
+module Procedures::Backup
+  class ConfigFiles < ForemanMaintain::Procedure
+    metadata do
+      description 'Backup config files'
+      tags :backup
+      preparation_steps do
+        if feature(:foreman_proxy) && !feature(:foreman_proxy).internal?
+          Checks::Backup::CertsTarExist.new
+        end
+      end
+      param :backup_dir, 'Directory where to backup to', :required => true
+      param :proxy_features, 'List of proxy features to backup (default: all)',
+            :array => true, :default => ['all']
+    end
+
+    def run
+      tarball = File.join(@backup_dir, 'config_files.tar.gz')
+      increments = File.join(@backup_dir, '.config.snar')
+      with_spinner('Collecting config files to backup') do
+        configs = config_files.join(' ')
+        execute!("tar --selinux --create --gzip --file=#{tarball} " \
+          "--listed-incremental=#{increments} --ignore-failed-read " \
+          "#{configs}")
+      end
+    end
+
+    def config_files
+      configs = []
+      # exclude proxy as it has special handling later
+      features = ForemanMaintain.available_features - [feature(:foreman_proxy)]
+      configs += features.inject([]) { |files, feature| files + feature.config_files }
+      configs += feature(:foreman_proxy).config_files(@proxy_features) if feature(:foreman_proxy)
+      configs.compact.select { |path| Dir.glob(path).any? }
+    end
+  end
+end

data/definitions/procedures/backup/metadata.rb

@@ -0,0 +1,56 @@
+module Procedures::Backup
+  class Metadata < ForemanMaintain::Procedure
+    metadata do
+      description 'Generate metadata'
+      tags :backup
+      preparation_steps { Checks::Foreman::DBUp.new if feature(:foreman_server) }
+      param :backup_dir, 'Directory where to backup to', :required => true
+      param :incremental_dir, 'Changes since specified backup only'
+    end
+
+    def run
+      with_spinner('Collecting metadata') do |spinner|
+        metadata = {}
+        metadata['os_version'] = release_info(spinner)
+        metadata['plugin_list'] = plugin_list(spinner) || []
+        metadata['proxy_features'] = proxy_feature_list(spinner) || []
+        metadata['rpms'] = rpms(spinner)
+        metadata['incremental'] = @incremental_dir || false
+        save_metadata(metadata, spinner)
+      end
+    end
+
+    private
+
+    def save_metadata(metadata, spinner)
+      spinner.update('Saving metadata to metadata.yml')
+      File.open(File.join(@backup_dir, 'metadata.yml'), 'w') do |metadata_file|
+        metadata_file.puts metadata.to_yaml
+      end
+    end
+
+    def release_info(spinner)
+      spinner.update('Collecting system release info')
+      execute!('cat /etc/redhat-release').chomp
+    end
+
+    def rpms(spinner)
+      spinner.update('Collecting installed RPMs')
+      execute!('rpm -qa').split("\n")
+    end
+
+    def plugin_list(spinner)
+      if feature(:foreman_server)
+        spinner.update('Collecting list of plugins')
+        feature(:foreman_server).plugins
+      end
+    end
+
+    def proxy_feature_list(spinner)
+      if feature(:foreman_proxy)
+        spinner.update('Collecting list of proxy features')
+        feature(:foreman_proxy).features
+      end
+    end
+  end
+end

data/definitions/procedures/backup/offline/candlepin_db.rb

@@ -0,0 +1,57 @@
+module Procedures::Backup
+  module Offline
+    class CandlepinDB < ForemanMaintain::Procedure
+      metadata do
+        description 'Backup Candlepin DB offline'
+        tags :backup
+        label :backup_offline_candlepin_db
+        for_feature :candlepin_database
+        preparation_steps { Checks::Candlepin::DBUp.new unless feature(:candlepin_database).local? }
+        param :backup_dir, 'Directory where to backup to', :required => true
+        param :tar_volume_size, 'Size of tar volume (indicates splitting)'
+        param :mount_dir, 'Snapshot mount directory'
+      end
+
+      def run
+        if feature(:candlepin_database).local?
+          if File.exist?(pg_backup_file)
+            puts 'Already done'
+          else
+            local_backup
+          end
+        else
+          puts "Backup of #{pg_data_dir} is not supported for remote databases." \
+            ' Doing postgres dump instead...'
+          with_spinner('Getting Candlepin DB dump') do
+            feature(:candlepin_database).dump_db(File.join(@backup_dir, 'candlepin.dump'))
+          end
+        end
+      end
+
+      private
+
+      def local_backup
+        with_spinner("Collecting data from #{pg_data_dir}") do
+          feature(:candlepin_database).backup_local(
+            pg_backup_file,
+            :listed_incremental => File.join(@backup_dir, '.postgres.snar'),
+            :volume_size => @tar_volume_size,
+            :data_dir => pg_data_dir
+          )
+        end
+      end
+
+      def pg_backup_file
+        File.join(@backup_dir, 'pgsql_data.tar')
+      end
+
+      def pg_data_dir
+        return feature(:candlepin_database).data_dir if @mount_dir.nil?
+        mount_point = File.join(@mount_dir, 'pgsql')
+        dir = feature(:candlepin_database).find_base_directory(mount_point)
+        fail!("Snapshot of Candlepin DB was not found mounted in #{mount_point}") if dir.nil?
+        dir
+      end
+    end
+  end
+end

data/definitions/procedures/backup/offline/foreman_db.rb

@@ -0,0 +1,57 @@
+module Procedures::Backup
+  module Offline
+    class ForemanDB < ForemanMaintain::Procedure
+      metadata do
+        description 'Backup Foreman DB offline'
+        tags :backup
+        label :backup_offline_foreman_db
+        for_feature :foreman_database
+        preparation_steps { Checks::Foreman::DBUp.new unless feature(:foreman_database).local? }
+        param :backup_dir, 'Directory where to backup to', :required => true
+        param :tar_volume_size, 'Size of tar volume (indicates splitting)'
+        param :mount_dir, 'Snapshot mount directory'
+      end
+
+      def run
+        if feature(:foreman_database).local?
+          if File.exist?(pg_backup_file)
+            puts 'Already done'
+          else
+            local_backup
+          end
+        else
+          puts "Backup of #{pg_data_dir} is not supported for remote databases." \
+            ' Doing postgres dump instead...'
+          with_spinner('Getting Foreman DB dump') do
+            feature(:foreman_database).dump_db(File.join(@backup_dir, 'foreman.dump'))
+          end
+        end
+      end
+
+      private
+
+      def local_backup
+        with_spinner("Collecting data from #{pg_data_dir}") do
+          feature(:foreman_database).backup_local(
+            pg_backup_file,
+            :listed_incremental => File.join(@backup_dir, '.postgres.snar'),
+            :volume_size => @tar_volume_size,
+            :data_dir => pg_data_dir
+          )
+        end
+      end
+
+      def pg_backup_file
+        File.join(@backup_dir, 'pgsql_data.tar')
+      end
+
+      def pg_data_dir
+        return feature(:foreman_database).data_dir if @mount_dir.nil?
+        mount_point = File.join(@mount_dir, 'pgsql')
+        dir = feature(:foreman_database).find_base_directory(mount_point)
+        fail!("Snapshot of Foreman DB was not found mounted in #{mount_point}") if dir.nil?
+        dir
+      end
+    end
+  end
+end

data/definitions/procedures/backup/offline/mongo.rb

@@ -0,0 +1,56 @@
+module Procedures::Backup
+  module Offline
+    class Mongo < ForemanMaintain::Procedure
+      metadata do
+        description 'Backup mongo offline'
+        tags :backup
+        for_feature :mongo
+        preparation_steps do
+          unless feature(:mongo).local?
+            [Checks::Mongo::DBUp.new, Checks::Mongo::ToolsInstalled.new]
+          end
+        end
+        param :backup_dir, 'Directory where to backup to', :required => true
+        param :tar_volume_size, 'Size of tar volume (indicates splitting)'
+        param :mount_dir, 'Snapshot mount directory'
+      end
+
+      def run
+        if feature(:mongo).local?
+          local_backup
+        else
+          dump_mongo
+        end
+      end
+
+      def data_dir
+        return nil if @mount_dir.nil?
+        mount_point = File.join(@mount_dir, 'mongodb')
+        dir = feature(:mongo).find_base_directory(mount_point)
+        fail!("Snapshot of Mongo DB was not found mounted in #{mount_point}") if dir.nil?
+        dir
+      end
+
+      private
+
+      def dump_mongo
+        puts "Backup of #{feature(:mongo).data_dir} is not supported for remote databases." \
+            ' Doing dump instead... '
+        with_spinner('Getting dump of Mongo DB') do
+          feature(:mongo).dump(File.join(@backup_dir, 'mongo_dump'))
+        end
+      end
+
+      def local_backup
+        with_spinner('Collecting Mongo data') do
+          feature(:mongo).backup_local(
+            File.join(@backup_dir, 'mongo_data.tar'),
+            :listed_incremental => File.join(@backup_dir, '.mongo.snar'),
+            :volume_size => @tar_volume_size,
+            :data_dir => data_dir
+          )
+        end
+      end
+    end
+  end
+end

data/definitions/procedures/backup/online/candlepin_db.rb

@@ -0,0 +1,20 @@
+module Procedures::Backup
+  module Online
+    class CandlepinDB < ForemanMaintain::Procedure
+      metadata do
+        description 'Backup Candlepin database online'
+        tags :backup
+        label :backup_online_candlepin_db
+        for_feature :candlepin_database
+        preparation_steps { Checks::Candlepin::DBUp.new }
+        param :backup_dir, 'Directory where to backup to', :required => true
+      end
+
+      def run
+        with_spinner('Getting Candlepin DB dump') do
+          feature(:candlepin_database).dump_db(File.join(@backup_dir, 'candlepin.dump'))
+        end
+      end
+    end
+  end
+end

data/definitions/procedures/backup/online/foreman_db.rb

@@ -0,0 +1,20 @@
+module Procedures::Backup
+  module Online
+    class ForemanDB < ForemanMaintain::Procedure
+      metadata do
+        description 'Backup Foreman database online'
+        tags :backup
+        label :backup_online_foreman_db
+        for_feature :foreman_database
+        preparation_steps { Checks::Foreman::DBUp.new }
+        param :backup_dir, 'Directory where to backup to', :required => true
+      end
+
+      def run
+        with_spinner('Getting Foreman DB dump') do
+          feature(:foreman_database).dump_db(File.join(@backup_dir, 'foreman.dump'))
+        end
+      end
+    end
+  end
+end