foreman_maintain 0.3.6 → 0.4.1

data/definitions/checks/repositories/validate.rb

@@ -18,8 +18,8 @@ module Checks::Repositories
     end
 
     def run
-      if feature(:downstream).subscribed_using_activationkey?
-        skip 'Your system is subscribed using custom activationkey'
+      if feature(:downstream).subscribed_using_activation_key?
+        skip 'Your system is subscribed using custom activation key'
       else
         with_spinner("Validating availability of repositories for #{@version}") do |spinner|
           find_absent_repos(spinner)

data/definitions/features/cron.rb

@@ -0,0 +1,29 @@
+class Features::Cron < ForemanMaintain::Feature
+  metadata do
+    label :cron
+    confine do
+      ForemanMaintain.config.manage_crond && !(
+        feature(:downstream) && feature(:downstream).less_than_version?('6.3')
+      )
+    end
+  end
+
+  def status_for_maintenance_mode(mode_on)
+    cron_service = system_service(service_name)
+    if cron_service.running?
+      [
+        'cron jobs: running',
+        mode_on ? [Procedures::Service::Stop.new(:only => [cron_service])] : []
+      ]
+    else
+      [
+        'cron jobs: not running',
+        mode_on ? [] : [Procedures::Service::Start.new(:only => [cron_service])]
+      ]
+    end
+  end
+
+  def service_name
+    'crond'
+  end
+end

data/definitions/features/downstream.rb

@@ -50,7 +50,7 @@ class Features::Downstream < ForemanMaintain::Feature
     execute!(%(subscription-manager refresh))
   end
 
-  def subscribed_using_activationkey?
+  def subscribed_using_activation_key?
     ENV['EXTERNAL_SAT_ACTIVATION_KEY'] && ENV['EXTERNAL_SAT_ORG']
   end
 
@@ -64,7 +64,7 @@ class Features::Downstream < ForemanMaintain::Feature
 
     rh_repos.concat(sat_and_tools_repos(rh_version_major, sat_version))
 
-    rh_repos << 'rhel-7-server-ansible-2.6-rpms' if sat_version >= version('6.4')
+    rh_repos << 'rhel-7-server-ansible-2.6-rpms' if sat_version.to_s == '6.4'
 
     if current_minor_version == '6.3' && sat_version.to_s != '6.4' && (
       feature(:puppet_server) && feature(:puppet_server).puppet_version.major == 4)
@@ -81,7 +81,7 @@ class Features::Downstream < ForemanMaintain::Feature
     sat_maintenance_repo_id = "rhel-#{rh_version_major}-server-satellite-maintenance-6-rpms"
 
     # Override to use Beta repositories for sat version until GA
-    if ENV['FOREMAN_MAINTAIN_USE_BETA'] == '1'
+    if sat_version.to_s == '6.5'
       sat_repo_id = "rhel-server-#{rh_version_major}-satellite-6-beta-rpms"
       sat_tools_repo_id = "rhel-#{rh_version_major}-server-satellite-tools-6-beta-rpms"
       sat_maintenance_repo_id = "rhel-#{rh_version_major}-server-satellite-maintenance-6-beta-rpms"

data/definitions/features/foreman_1_7_x.rb

@@ -6,39 +6,4 @@ class Features::Foreman_1_7_x < ForemanMaintain::Feature
       check_min_version('foreman', '1.7')
     end
   end
-
-  def maintenance_mode(enable_disable)
-    case enable_disable
-    when :enable
-      custom_iptables_chain('FOREMAN_MAINTAIN',
-                            ['-i lo -j ACCEPT',
-                             '-p tcp --dport 443 -j REJECT'])
-    when :disable
-      del_custom_iptables_chain('FOREMAN_MAINTAIN')
-    else
-      raise "Unexpected argument #{enable_disable}"
-    end
-  end
-
-  private
-
-  def custom_iptables_chain(name, rules)
-    # if the chain already exists, we assume it was set before: we're not touching
-    # it again
-    return if execute?("iptables -L #{name}")
-    execute!("iptables -N #{name}")
-    rules.each do |rule|
-      execute!("iptables -A #{name} #{rule}")
-    end
-    execute!("iptables -I INPUT -j #{name}")
-  end
-
-  def del_custom_iptables_chain(name)
-    return unless execute?("iptables -L #{name}") # the chain is already gone
-    if execute?("iptables -L INPUT | tail -n +3 | grep '^#{name} '")
-      execute!("iptables -D INPUT -j #{name}")
-    end
-    execute!("iptables -F #{name}")
-    execute!("iptables -X #{name}")
-  end
 end

data/definitions/features/foreman_database.rb

@@ -15,12 +15,6 @@ class Features::ForemanDatabase < ForemanMaintain::Feature
     @configuration || load_configuration
   end
 
-  def config_files
-    [
-      '/var/lib/pgsql/data/postgresql.conf'
-    ]
-  end
-
   def services
     [
       system_service('postgresql', 10, :component => 'foreman',

data/definitions/features/iptables.rb

@@ -0,0 +1,58 @@
+class Features::Iptables < ForemanMaintain::Feature
+  metadata do
+    label :iptables
+  end
+
+  def add_chain(chain_name, rules, rule_chain = 'INPUT')
+    # if the chain already exists, we assume it was set before: we're not touching
+    # it again
+    return if chain_exist?(chain_name)
+    execute!("iptables -N #{chain_name}")
+    rules.each do |rule|
+      execute!("iptables -A #{chain_name} #{rule}")
+    end
+    execute!("iptables -I #{rule_chain} -j #{chain_name}")
+  end
+
+  def remove_chain(chain_name, rule_chain = 'INPUT')
+    return unless chain_exist?(chain_name) # the chain is already gone
+    execute!("iptables -D #{rule_chain} -j #{chain_name}") if rule_exist?(chain_name, rule_chain)
+    execute!("iptables -F #{chain_name}")
+    execute!("iptables -X #{chain_name}")
+  end
+
+  def chain_exist?(chain_name)
+    execute?("iptables -L #{chain_name}")
+  end
+
+  def rule_exist?(target_name, rule_chain = 'INPUT')
+    execute?("iptables -L #{rule_chain} | tail -n +3 | grep '^#{target_name} '")
+  end
+
+  def add_maintenance_mode_chain
+    add_chain(custom_chain_name,
+              ['-i lo -j ACCEPT', '-p tcp --dport 443 -j REJECT'])
+  end
+
+  def remove_maintenance_mode_chain
+    remove_chain(custom_chain_name)
+  end
+
+  def maintenance_mode_chain_exist?
+    chain_exist?(custom_chain_name)
+  end
+
+  def status_for_maintenance_mode
+    if maintenance_mode_chain_exist?
+      ['Iptables chain: present', []]
+    else
+      ['Iptables chain: absent', []]
+    end
+  end
+
+  private
+
+  def custom_chain_name
+    'FOREMAN_MAINTAIN'
+  end
+end

data/definitions/features/mongo.rb

@@ -1,4 +1,6 @@
 class Features::Mongo < ForemanMaintain::Feature
+  include ForemanMaintain::Concerns::DirectoryMarker
+
   # assume mongo is installed when there is Pulp
   PULP_DB_CONFIG = '/etc/pulp/server.conf'.freeze
 
@@ -95,30 +97,30 @@ class Features::Mongo < ForemanMaintain::Feature
 
   def dump(target, config = configuration)
     execute!(base_command(core.dump_command, config, "-d #{config['name']} --out #{target}"),
-             :hidden_patterns => [config['password']].compact)
+             :hidden_patterns => [config['password']])
   end
 
   def restore(dir, config = configuration)
     cmd = base_command(core.restore_command, config,
                        "-d #{config['name']} #{File.join(dir, config['name'])}")
-    execute!(cmd, :hidden_patterns => [config['password']].compact)
+    execute!(cmd, :hidden_patterns => [config['password']])
   end
 
   def dropdb(config = configuration)
     execute!(mongo_command("--eval 'db.dropDatabase()'", config),
-             :hidden_patterns => [config['password']].compact)
+             :hidden_patterns => [config['password']])
   end
 
   def ping(config = configuration)
     execute?(mongo_command("--eval 'ping:1'", config),
-             :hidden_patterns => [config['password']].compact)
+             :hidden_patterns => [config['password']])
   end
 
   def server_version(config = configuration)
     # do not use any core methods as we need this prior the core is created
     mongo_cmd = base_command(available_core.client_command, config,
                              "--eval 'db.version()' #{config['name']}")
-    version = execute!(mongo_cmd, :hidden_patterns => [config['password']].compact)
+    version = execute!(mongo_cmd, :hidden_patterns => [config['password']])
     version.split("\n").last
   end
 
@@ -138,10 +140,6 @@ class Features::Mongo < ForemanMaintain::Feature
     end
   end
 
-  def find_base_directory(directory)
-    find_dir_containing_file(directory, 'mongod.lock')
-  end
-
   private
 
   def load_mongo_core_default(version)

data/definitions/features/pulp.rb

@@ -1,4 +1,6 @@
 class Features::Pulp < ForemanMaintain::Feature
+  include ForemanMaintain::Concerns::DirectoryMarker
+
   metadata do
     label :pulp
 
@@ -36,8 +38,4 @@ class Features::Pulp < ForemanMaintain::Feature
       '/etc/qpid-dispatch'
     ]
   end
-
-  def find_base_directory(directory)
-    find_dir_containing_file(directory, '0005_puppet_module_name_change.txt')
-  end
 end

data/definitions/features/puppet_server.rb

@@ -2,19 +2,60 @@ class Features::PuppetServer < ForemanMaintain::Feature
   metadata do
     label :puppet_server
 
-    # We only check puppetserver and not puppet-server, as puppet-server
-    # is a part of httpd and relies on httpd service to restart, therefore
-    # not requiring a separate service to restart
     confine do
-      find_package('puppetserver') || find_package('puppet')
+      find_package('puppet-server') || find_package('puppetserver') || find_package('puppet')
     end
   end
 
+  def config_files
+    [
+      '/etc/puppet',
+      '/etc/puppetlabs',
+      '/opt/puppetlabs/puppet/cache/foreman_cache_data',
+      '/var/lib/puppet/foreman_cache_data',
+      '/opt/puppetlabs/puppet/ssl/',
+      '/var/lib/puppet/ssl',
+      '/var/lib/puppet',
+      '/usr/share/ruby/vendor_ruby/puppet/reports/foreman.rb',
+      '/opt/puppetlabs/puppet/lib/ruby/vendor_ruby/puppet/reports/foreman.rb'
+    ]
+  end
+
   def services
+    # We only check puppetserver and not puppet-server, as puppet-server
+    # is a part of httpd and relies on httpd service to restart, therefore
+    # not requiring a separate service to restart
     find_package('puppetserver') ? [system_service('puppetserver', 30)] : []
   end
 
   def puppet_version
     version(execute!('puppet --version'))
   end
+
+  def find_empty_cacert_request_files
+    cmd_output = execute!("find #{cacert_requests_directory} -type f -size 0 | paste -d, -s")
+    cmd_output.split(',')
+  end
+
+  def delete_empty_cacert_files
+    execute!("find #{cacert_requests_directory} -type f -size 0 -delete")
+  end
+
+  def cacert_requests_directory
+    "#{ca_directory_path}/requests"
+  end
+
+  def cacert_requests_dir_exists?
+    File.directory?(cacert_requests_directory)
+  end
+
+  private
+
+  def ca_directory_path
+    "#{puppet_ssldir_path}/ca"
+  end
+
+  def puppet_ssldir_path
+    execute!('puppet master --configprint ssldir')
+  end
 end

data/definitions/features/service.rb

@@ -4,9 +4,11 @@ class Features::Service < ForemanMaintain::Feature
   end
 
   def handle_services(spinner, action, options = {})
-    # options is used to handle "exclude" and "only" i.e.
+    # options is used to handle "exclude" and "only" and "include" i.e.
     # { :only => ["httpd"] }
     # { :exclude => ["pulp-workers", "tomcat"] }
+    # { :include => ["crond"] }
+
     if feature(:downstream) && feature(:downstream).less_than_version?('6.3')
       use_katello_service(action, options)
     else
@@ -28,6 +30,7 @@ class Features::Service < ForemanMaintain::Feature
     service_list = existing_services
     service_list = filter_services(service_list, options)
     raise 'No services found matching your parameters' unless service_list.any?
+
     options[:reverse] ? service_list.reverse : service_list
   end
 
@@ -50,6 +53,7 @@ class Features::Service < ForemanMaintain::Feature
     spinner.update("All services #{action_past_tense(action)}")
     if action == 'status'
       raise "Some services are not running (#{failed_services.join(', ')})" if status > 0
+
       spinner.update('All services are running')
     end
   end
@@ -96,14 +100,39 @@ class Features::Service < ForemanMaintain::Feature
   end
 
   def filter_services(service_list, options)
+    service_list = include_unregistered_services(service_list, options[:include])
+
     if options[:only] && options[:only].any?
       service_list = service_list.select do |service|
         options[:only].any? { |opt| service.matches?(opt) }
       end
+      service_list = include_unregistered_services(service_list, options[:only])
     end
+
     if options[:exclude] && options[:exclude].any?
       service_list = service_list.reject { |service| options[:exclude].include?(service.name) }
     end
+    service_list.sort
+  end
+
+  def include_unregistered_services(service_list, services_filter)
+    return service_list unless services_filter
+    return service_list unless services_filter.any?
+
+    services_filter = services_filter.reject do |obj|
+      service_list.any? { |service| service.matches?(obj) }
+    end
+
+    unregistered_service_list = services_filter.map do |obj|
+      service = if obj.is_a? String
+                  system_service(obj)
+                elsif valid_sys_service?(obj)
+                  obj
+                end
+      service.exist? ? service : raise("No service found matching your parameter '#{service.name}'")
+    end
+
+    service_list.concat(unregistered_service_list)
     service_list
   end
 
@@ -140,7 +169,9 @@ class Features::Service < ForemanMaintain::Feature
 
   def run_katello_service(command)
     puts "Services are handled by katello-service in Satellite versions 6.2 and earlier. \n" \
-         "Flags --brief or --failing will be ignored if present. Redirecting to: \n#{command}\n"
+         "Flags --brief or --failing will be ignored if present. \n"\
+         "Similarly, services that are not listed by katello-service will get ignored. \n"\
+         "Redirecting to: \n#{command}\n"
     puts execute(command)
   end
 

data/definitions/features/sync_plans.rb

@@ -3,34 +3,33 @@ class Features::SyncPlans < ForemanMaintain::Feature
     label :sync_plans
   end
 
-  def required_new_implementation
-    @required_new_implementation ||=
-      feature(:foreman_database).query(
-        <<-SQL
-          SELECT COUNT(1) FROM information_schema.table_constraints
-          WHERE constraint_name='katello_sync_plan_foreman_tasks_recurring_logic_fk' AND table_name='katello_sync_plans'
-        SQL
-      ).first['count'].to_i > 0
+  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 sync_plan_ids_by_status(enabled = true, filter_ids = nil)
-    if filter_ids
-      return [] if filter_ids.empty?
+  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
 
-      ids_condition = filter_ids.map { |id| "'#{id}'" }.join(',')
-    end
+  def verify_existing_ids_by_status(ids, enabled = true)
+    return [] if ids.empty?
 
-    if required_new_implementation
-      query = <<-SQL
-        select sp.id as id from katello_sync_plans sp inner join foreman_tasks_recurring_logics rl on sp.foreman_tasks_recurring_logic_id = rl.id
-        where rl.state='#{enabled ? 'active' : 'disabled'}' #{ids_condition ? " AND sp.id IN (#{ids_condition})" : ''}
+    enabled = enabled ? 't' : 'f'
+    ids_condition = ids.map { |id| "'#{id}'" }.join(',')
+    feature(:foreman_database).query(
+      <<-SQL
+        SELECT id FROM katello_sync_plans WHERE enabled ='#{enabled}' AND id IN (#{ids_condition})
       SQL
-    else
-      query = <<-SQL
-        SELECT id FROM katello_sync_plans WHERE enabled ='#{enabled ? 't' : 'f'}' #{ids_condition ? " AND id IN (#{ids_condition})" : ''}
-      SQL
-    end
-    feature(:foreman_database).query(query).map { |r| r['id'].to_i }
+    ).map { |r| r['id'].to_i }
   end
 
   def make_disable(ids)
@@ -49,10 +48,28 @@ class Features::SyncPlans < ForemanMaintain::Feature
     storage[:sync_plans] = @data
   end
 
+  def status_for_maintenance_mode(mode_on)
+    default_storage = ForemanMaintain.storage(:default)
+    load_from_storage(default_storage)
+    return ['sync plans: empty data', []] if both_empty?
+
+    if @data[:enabled] && key_empty?(:disabled)
+      [
+        'sync plans: enabled',
+        mode_on ? [Procedures::SyncPlans::Disable.new] : []
+      ]
+    else
+      [
+        'sync plans: disabled',
+        mode_on ? [] : [Procedures::SyncPlans::Enable.new]
+      ]
+    end
+  end
+
   private
 
   def update_records(ids, enabled)
-    ids_not_required_update = sync_plan_ids_by_status(enabled, ids)
+    ids_not_required_update = verify_existing_ids_by_status(ids, enabled)
     ids_required_update = ids - ids_not_required_update
     make_data_key_empty(enabled) if !ids_not_required_update.empty? && ids_required_update.empty?
     updated_record_ids = []
@@ -87,7 +104,15 @@ class Features::SyncPlans < ForemanMaintain::Feature
     else
       @data[:disabled] = [] unless @data[:disabled]
       @data[:enabled] = [] if @data[:disabled].empty?
-      @data[:disabled].concat(new_ids).uniq!
+      @data[:disabled].concat(new_ids)
     end
   end
+
+  def both_empty?
+    key_empty?(:disabled) && key_empty?(:enabled)
+  end
+
+  def key_empty?(key_name)
+    (@data[key_name].nil? || @data[key_name] && @data[key_name].empty?)
+  end
 end