foreman_maintain 0.0.2 → 0.0.3

data/definitions/features/downstream.rb

@@ -1,8 +1,10 @@
 class Features::Downstream < ForemanMaintain::Feature
-  label :downstream
+  metadata do
+    label :downstream
 
-  confine do
-    downstream_installation?
+    confine do
+      downstream_installation?
+    end
   end
 
   def current_version

data/definitions/features/foreman_1_11_x.rb

@@ -1,7 +1,9 @@
 require 'features/foreman_1_7_x'
 
 class Features::Foreman_1_11_x < Features::Foreman_1_7_x
-  confine do
-    check_min_version('foreman', '1.11')
+  metadata do
+    confine do
+      check_min_version('foreman', '1.11')
+    end
   end
 end

data/definitions/features/foreman_1_7_x.rb

@@ -1,7 +1,9 @@
 class Features::Foreman_1_7_x < 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
 end

data/definitions/features/foreman_database.rb

@@ -1,15 +1,21 @@
 class Features::ForemanDatabase < ForemanMaintain::Feature
-  label :foreman_database
+  metadata do
+    label :foreman_database
 
-  confine do
-    File.exist?('/etc/foreman/database.yml')
+    confine do
+      File.exist?('/etc/foreman/database.yml')
+    end
   end
 
   def query(sql)
-    parse_csv(psql(%{COPY (#{sql}) TO STDOUT WITH CSV HEADER}))
+    parse_csv(query_csv(sql))
+  end
+
+  def query_csv(sql)
+    psql(%{COPY (#{sql}) TO STDOUT WITH CSV HEADER})
   end
 
   def psql(query)
-    execute("su - postgres -c 'psql -d foreman'", query)
+    execute("su - postgres -c 'psql -d foreman'", :stdin => query)
   end
 end

data/definitions/features/foreman_tasks.rb

@@ -1,9 +1,35 @@
 class Features::ForemanTasks < ForemanMaintain::Feature
-  label :foreman_tasks
+  MIN_AGE = 30
 
-  confine do
-    check_min_version('ruby193-rubygem-foreman-tasks', '0.6') ||
-      check_min_version('tfm-rubygem-foreman-tasks', '0.7')
+  SAFE_TO_DELETE = %w[
+    Actions::Katello::Host::GenerateApplicability
+    Actions::Katello::RepositorySet::ScanCdn
+    Actions::Katello::Host::Hypervisors
+    Actions::Katello::Host::HypervisorsUpdate
+    Actions::Foreman::Host::ImportFacts
+    Actions::Candlepin::ListenOnCandlepinEvents
+    Actions::Katello::EventQueue::Monitor
+  ].freeze
+
+  metadata do
+    label :foreman_tasks
+
+    confine do
+      check_min_version('ruby193-rubygem-foreman-tasks', '0.6') ||
+        check_min_version('tfm-rubygem-foreman-tasks', '0.7')
+    end
+  end
+
+  def backup_tasks(state)
+    backup_table('dynflow_execution_plans', state, 'uuid') { |status| yield(status) }
+    backup_table('dynflow_steps', state) { |status| yield(status) }
+    backup_table('dynflow_actions', state) { |status| yield(status) }
+
+    yield('Backup Tasks [running]')
+    export_csv("SELECT * FROM foreman_tasks_tasks WHERE #{condition(state)}",
+               'foreman_tasks_tasks.csv', state)
+    yield('Backup Tasks [DONE]')
+    @backup_dir = nil
   end
 
   def running_tasks_count
@@ -13,10 +39,93 @@ class Features::ForemanTasks < ForemanMaintain::Feature
     0
   end
 
-  def paused_tasks_count
-    # feature(:foreman_database).query(<<-SQL).first['count'].to_i
-    #  SELECT count(*) AS count FROM foreman_tasks_tasks WHERE state in ('running', 'paused')
-    # SQL
-    5
+  def paused_tasks_count(ignored_tasks = [])
+    sql = <<-SQL
+      SELECT count(*) AS count
+        FROM foreman_tasks_tasks
+        WHERE state IN ('paused')
+    SQL
+    unless ignored_tasks.empty?
+      sql << "AND label NOT IN (#{quotize(ignored_tasks)})"
+    end
+    feature(:foreman_database).query(sql).first['count'].to_i
+  end
+
+  def count(state)
+    feature(:foreman_database).query(<<-SQL).first['count'].to_i
+     SELECT count(*) AS count FROM foreman_tasks_tasks WHERE #{condition(state)}
+    SQL
+  end
+
+  def delete(state)
+    tasks_condition = condition(state)
+
+    feature(:foreman_database).psql(<<-SQL)
+     BEGIN;
+       DELETE FROM dynflow_steps USING foreman_tasks_tasks WHERE (foreman_tasks_tasks.external_id = dynflow_steps.execution_plan_uuid) AND #{tasks_condition};
+       DELETE FROM dynflow_actions USING foreman_tasks_tasks WHERE (foreman_tasks_tasks.external_id = dynflow_actions.execution_plan_uuid) AND #{tasks_condition};
+       DELETE FROM dynflow_execution_plans USING foreman_tasks_tasks WHERE (foreman_tasks_tasks.external_id = dynflow_execution_plans.uuid) AND #{tasks_condition};
+       DELETE FROM foreman_tasks_tasks WHERE #{tasks_condition};
+     COMMIT;
+    SQL
+
+    count(state)
+  end
+
+  def condition(state)
+    raise 'Invalid State' unless valid(state)
+
+    if state == :old
+      old_tasks_condition
+    else
+      tasks_condition(state)
+    end
+  end
+
+  private
+
+  def backup_dir(state)
+    @backup_dir ||=
+      "/var/lib/foreman/backup-tasks/#{state}/#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}"
+  end
+
+  def backup_table(table, state, fkey = 'execution_plan_uuid')
+    yield("Backup #{table} [running]")
+    sql = "SELECT #{table}.* FROM foreman_tasks_tasks JOIN #{table} ON\
+       (foreman_tasks_tasks.external_id = #{table}.#{fkey})"
+    export_csv(sql, "#{table}.csv", state)
+    yield("Backup #{table} [DONE]")
+  end
+
+  def export_csv(sql, file_name, state)
+    dir = prepare_for_backup(state)
+    filepath = "#{dir}/#{file_name}"
+    execute("echo \"COPY (#{sql}) TO STDOUT WITH CSV;\" \
+      | su - postgres -c '/usr/bin/psql -d foreman' | bzip2 -9 > #{filepath}.bz2")
+  end
+
+  def old_tasks_condition(state = "'stopped', 'paused'")
+    "foreman_tasks_tasks.state IN (#{state}) AND " \
+       "foreman_tasks_tasks.started_at < CURRENT_DATE - INTERVAL '#{MIN_AGE} days'"
+  end
+
+  def prepare_for_backup(state)
+    dir = backup_dir(state)
+    execute("mkdir -p #{dir}")
+    dir
+  end
+
+  def quotize(array)
+    array.map { |el| "'#{el}'" }.join(',')
+  end
+
+  def tasks_condition(state)
+    safe_to_delete_tasks = quotize(SAFE_TO_DELETE)
+    "foreman_tasks_tasks.state = '#{state}' AND " \
+    "foreman_tasks_tasks.label IN (#{safe_to_delete_tasks})"
+  end
+
+  def valid(state)
+    [:old, :planning, :pending].include?(state)
   end
 end

data/definitions/features/sync_plans.rb

@@ -0,0 +1,75 @@
+class Features::SyncPlans < ForemanMaintain::Feature
+  metadata do
+    label :sync_plans
+  end
+
+  def active_sync_plans_count
+    feature(:foreman_database).query(
+      <<-SQL
+        SELECT count(*) AS count FROM katello_sync_plans WHERE enabled ='t'
+      SQL
+    ).first['count'].to_i
+  end
+
+  def ids_by_status(enabled = true)
+    enabled = enabled ? 't' : 'f'
+    feature(:foreman_database).query(
+      <<-SQL
+        SELECT id FROM katello_sync_plans WHERE enabled ='#{enabled}'
+      SQL
+    ).map { |r| r['id'].to_i }
+  end
+
+  def disabled_plans_count
+    data[:disabled].length
+  end
+
+  def make_disable(ids)
+    update_records(ids, false)
+  end
+
+  def make_enable
+    update_records(data[:disabled], true)
+  end
+
+  private
+
+  def update_records(ids, enabled)
+    updated_record_ids = []
+    ids.each do |sp_id|
+      result = hammer("sync-plan update --id #{sp_id} --enabled #{enabled}")
+      if result.include?('Sync plan updated')
+        updated_record_ids << sp_id
+      else
+        raise result
+      end
+    end
+    updated_record_ids
+  ensure
+    new_data = sync_plan_data(enabled, updated_record_ids)
+    save_state(new_data)
+  end
+
+  def data
+    upgrade_storage = ForemanMaintain.storage(:upgrade)
+    @data ||= upgrade_storage.data.fetch(:sync_plans, :enabled => [], :disabled => [])
+    @data
+  end
+
+  def sync_plan_data(enabled, new_ids)
+    sync_plan_hash = data
+    if enabled
+      sync_plan_hash[:disabled] -= new_ids
+      sync_plan_hash[:enabled] = new_ids
+    else
+      sync_plan_hash[:disabled].concat(new_ids)
+    end
+    sync_plan_hash
+  end
+
+  def save_state(sync_plan_hash = {})
+    storage = ForemanMaintain.storage(:upgrade)
+    storage[:sync_plans] = sync_plan_hash
+    storage.save
+  end
+end

data/definitions/features/upstream.rb

@@ -1,7 +1,9 @@
 class Features::Upstream < ForemanMaintain::Feature
-  label :upstream
+  metadata do
+    label :upstream
 
-  confine do
-    !downstream_installation?
+    confine do
+      !downstream_installation?
+    end
   end
 end

data/definitions/procedures/foreman_tasks/delete.rb

@@ -0,0 +1,33 @@
+module Procedures::ForemanTasks
+  class Delete < ForemanMaintain::Procedure
+    metadata do
+      param :state, 'In what state should the task be deleted'
+    end
+
+    def run
+      with_spinner("Deleting #{@state} task") do |spinner|
+        count_tasks_before = feature(:foreman_tasks).count(@state)
+
+        if count_tasks_before > 0
+          spinner.update "Backup #{@state} tasks"
+
+          feature(:foreman_tasks).backup_tasks(@state) do |backup_progress|
+            spinner.update backup_progress
+          end
+
+          spinner.update "Deleting #{@state} tasks [running]"
+          count_tasks_later = feature(:foreman_tasks).delete(@state)
+          spinner.update "Deleting #{@state} tasks [DONE]"
+        end
+
+        spinner.update(
+          "Deleted #{@state} stopped and paused tasks: #{count_tasks_before - count_tasks_later}"
+        )
+      end
+    end
+
+    def description
+      "Delete #{@state} tasks"
+    end
+  end
+end

data/definitions/procedures/foreman_tasks/resume.rb

@@ -0,0 +1,14 @@
+module Procedures::ForemanTasks
+  class Resume < ForemanMaintain::Procedure
+    include ForemanMaintain::Concerns::Hammer
+
+    metadata do
+      for_feature :foreman_tasks
+      description 'resume paused tasks'
+    end
+
+    def run
+      output << hammer('task resume')
+    end
+  end
+end

data/definitions/procedures/foreman_tasks/ui_investigate.rb

@@ -0,0 +1,19 @@
+require 'cgi'
+module Procedures::ForemanTasks
+  class UiInvestigate < ForemanMaintain::Procedure
+    metadata do
+      for_feature :foreman_tasks
+      description 'investigate the tasks via UI'
+      param :search_query
+    end
+
+    attr_reader :search_query
+
+    def run
+      ask(<<-MESSAGE.strip_heredoc)
+        Go to https://#{hostname}/foreman_tasks/tasks?search=#{CGI.escape(@search_query.to_s)}
+        press ENTER after the paused tasks are resolved.
+      MESSAGE
+    end
+  end
+end

data/definitions/procedures/hammer_setup.rb

@@ -0,0 +1,50 @@
+class Procedures::HammerSetup < ForemanMaintain::Procedure
+  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
+  end
+
+  def necessary?
+    !hammer.ready?
+  end
+
+  def description
+    'Setup hammer'
+  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
+  end
+end

data/definitions/procedures/install_package.rb

@@ -0,0 +1,17 @@
+class Procedures::InstallPackage < ForemanMaintain::Procedure
+  metadata do
+    param :packages, 'List of packages to install', :array => true
+  end
+
+  def run
+    install_packages(@packages, :assumeyes => assumeyes?)
+  end
+
+  def necessary?
+    @packages.any? { |package| package_version(package).nil? }
+  end
+
+  def description
+    "Install package(s) #{@packages.join(', ')}"
+  end
+end

data/definitions/procedures/sync_plans/disable.rb

@@ -0,0 +1,22 @@
+module Procedures::SyncPlans
+  class Disable < ForemanMaintain::Procedure
+    metadata do
+      for_feature :sync_plans
+      description 'disable active sync plans'
+    end
+
+    def run
+      disable_all_enabled_sync_plans
+    end
+
+    private
+
+    def disable_all_enabled_sync_plans
+      with_spinner('disabling sync plans') do |spinner|
+        ids = feature(:sync_plans).ids_by_status(true)
+        feature(:sync_plans).make_disable(ids)
+        spinner.update "Total #{ids.length} sync plans are now disabled."
+      end
+    end
+  end
+end