foreman_maintain 0.1.6 → 0.2.0

data/definitions/features/instance.rb

@@ -0,0 +1,39 @@
+class Features::Instance < ForemanMaintain::Feature
+  metadata do
+    label :instance
+  end
+
+  def foreman_proxy_product_name
+    feature(:downstream) ? 'Capsule' : 'Foreman Proxy'
+  end
+
+  def server_product_name
+    if feature(:downstream)
+      'Satellite'
+    elsif feature(:katello)
+      'Katello'
+    else
+      'Foreman'
+    end
+  end
+
+  def external_proxy?
+    !!(feature(:foreman_proxy) && !feature(:foreman_server))
+  end
+
+  def product_name
+    if external_proxy?
+      foreman_proxy_product_name
+    else
+      server_product_name
+    end
+  end
+
+  def database_local?(feature)
+    !!feature(feature) && feature(feature).local?
+  end
+
+  def postgresql_local?
+    database_local?(:candlepin_database) || database_local?(:foreman_database)
+  end
+end

data/definitions/features/katello.rb

@@ -7,6 +7,7 @@ class Features::Katello < ForemanMaintain::Feature
     end
   end
 
+  # TODO: refactor to new features?
   def data_dirs
     @dirs ||= ['/var/lib/pulp', '/var/lib/mongodb', '/var/lib/pgsql']
   end
@@ -14,4 +15,46 @@ class Features::Katello < ForemanMaintain::Feature
   def current_version
     @current_version ||= rpm_version('katello')
   end
+
+  def services
+    {
+      'qpidd'                    => 10,
+      'qdrouterd'                => 10,
+      'goferd'                   => 30,
+      'elasticsearch'            => 30
+    }
+  end
+
+  # rubocop:disable  Metrics/MethodLength
+  def config_files
+    configs = [
+      '/etc/pki/katello',
+      '/etc/pki/katello-certs-tools',
+      '/etc/pki/ca-trust',
+      '/root/ssl-build',
+      '/etc/candlepin',
+      '/etc/sysconfig/tomcat*',
+      '/etc/tomcat*',
+      '/var/lib/candlepin',
+      '/usr/share/foreman/bundler.d/katello.rb'
+    ]
+
+    if installer_scenario_answers['certs']
+      configs += [
+        installer_scenario_answers['certs']['server_cert'],
+        installer_scenario_answers['certs']['server_key'],
+        installer_scenario_answers['certs']['server_cert_req'],
+        installer_scenario_answers['certs']['server_ca_cert']
+      ].compact
+    end
+
+    configs
+  end
+  # rubocop:enable  Metrics/MethodLength
+
+  private
+
+  def installer_scenario_answers
+    feature(:installer).answers
+  end
 end

data/definitions/features/mongo.rb

@@ -0,0 +1,159 @@
+class Features::Mongo < ForemanMaintain::Feature
+  # assume mongo is installed when there is Pulp
+  PULP_DB_CONFIG = '/etc/pulp/server.conf'.freeze
+
+  attr_reader :configuration
+  metadata do
+    label :mongo
+
+    confine do
+      feature(:pulp)
+    end
+  end
+
+  def services
+    core.services
+  end
+
+  def data_dir
+    '/var/lib/mongodb'
+  end
+
+  def config_files
+    [config_file] + (local? ? core.server_config_files : [])
+  end
+
+  def config_file
+    PULP_DB_CONFIG
+  end
+
+  def initialize
+    @configuration = load_db_config(config_file)
+  end
+
+  def core
+    if @core.nil?
+      version = server_version
+      @core = if version =~ /^3\.4/
+                logger.debug("Mongo #{version} detected, using commands from rh-mongodb34 SCL")
+                ForemanMaintain::Utils::MongoCore34.new
+              else
+                logger.debug("Mongo #{version} detected, using default commands")
+                ForemanMaintain::Utils::MongoCore.new
+              end
+    end
+    @core
+  end
+
+  def local?
+    ['localhost', '127.0.0.1', hostname].include?(configuration['host'])
+  end
+
+  def base_command(command, config = configuration, args = '')
+    if config['ssl']
+      ssl = ' --ssl'
+      if config['ca_path']
+        ca_cert = " --sslCAFile #{config['ca_path']}"
+        client_cert = " --sslPEMKeyFile #{config['ssl_certfile']}" if config['ssl_certfile']
+      end
+    end
+    username = " -u #{config['username']}" if config['username']
+    password = " -p #{config['password']}" if config['password']
+    host = "--host #{config['host']} --port #{config['port']}"
+    "#{command}#{username}#{password} #{host}#{ssl}#{ca_cert}#{client_cert} #{args}"
+  end
+
+  def mongo_command(args, config = configuration)
+    base_command(core.client_command, config, "#{args} #{config['name']}")
+  end
+
+  def dump(target, config = configuration)
+    execute!(base_command(core.dump_command, config, "-d #{config['name']} --out #{target}"),
+             :hidden_patterns => [config['password']].compact)
+  end
+
+  def dropdb(config = configuration)
+    execute!(mongo_command("--eval 'db.dropDatabase()'", config),
+             :hidden_patterns => [config['password']].compact)
+  end
+
+  def ping(config = configuration)
+    execute?(mongo_command("--eval 'ping:1'"),
+             :hidden_patterns => [config['password']].compact)
+  end
+
+  def server_version(config = configuration)
+    # do not use any core methods as we need this prior the core is created
+    version = execute(base_command('mongo', config, "--eval 'db.version()' #{config['name']}"),
+                      :hidden_patterns => [config['password']].compact)
+    version.split("\n").last
+  end
+
+  def backup_local(backup_file, extra_tar_options = {})
+    dir = extra_tar_options.fetch(:data_dir, nil) || data_dir
+    logger.info("Backup of Mongo DB at #{dir} into #{backup_file}")
+    logger.debug(extra_tar_options.inspect)
+    FileUtils.cd(dir) do
+      tar_options = {
+        :archive => backup_file,
+        :command => 'create',
+        :exclude => ['mongod.lock'],
+        :transform => 's,^,var/lib/mongodb/,S'
+      }.merge(extra_tar_options)
+      feature(:tar).run(tar_options)
+    end
+  end
+
+  def find_base_directory(directory)
+    find_dir_containing_file(directory, 'mongod.lock')
+  end
+
+  private
+
+  def norm_value(value)
+    value = value.strip
+    case value
+    when 'true'
+      true
+    when 'false'
+      false
+    else
+      value
+    end
+  end
+
+  def load_db_config(config)
+    cfg = read_db_section(config)
+    if cfg['seeds']
+      seed = cfg['seeds'].split(',').first
+      host, port = seed.split(':')
+    end
+    cfg['host'] = host || 'localhost'
+    cfg['port'] = port || '27017'
+    cfg
+  end
+
+  # rubocop:disable  Metrics/MethodLength
+  def read_db_section(config)
+    cfg = {}
+    section = nil
+    File.readlines(config).each do |line|
+      case line
+      when /^\s*#/
+        next # skip comments
+      when /^\s*$/
+        next # skip empty lines
+      when /\[([^\]]+)\]/
+        section = Regexp.last_match(1)
+        next
+      else
+        if section == 'database'
+          key, value = line.split(':', 2)
+          cfg[key.strip] = norm_value(value)
+        end
+      end
+    end
+    cfg
+  end
+  # rubocop:enable  Metrics/MethodLength
+end

data/definitions/features/pulp.rb

@@ -6,4 +6,34 @@ class Features::Pulp < ForemanMaintain::Feature
       find_package('pulp-server')
     end
   end
+
+  def services
+    {
+      'squid'                    => 10,
+      'pulp_workers'             => 20,
+      'pulp_celerybeat'          => 20,
+      'pulp_resource_manager'    => 20,
+      'pulp_streamer'            => 20
+    }
+  end
+
+  def data_dir
+    '/var/lib/pulp'
+  end
+
+  def config_files
+    [
+      '/etc/pki/pulp',
+      '/etc/pulp',
+      '/etc/qpid',
+      '/etc/qpid-dispatch',
+      '/etc/crane.conf',
+      '/etc/default/pulp_workers',
+      '/var/lib/qpidd'
+    ]
+  end
+
+  def find_base_directory(directory)
+    find_dir_containing_file(directory, '0005_puppet_module_name_change.txt')
+  end
 end

data/definitions/features/puppet.rb

@@ -0,0 +1,21 @@
+class Features::Puppet < ForemanMaintain::Feature
+  metadata do
+    label :puppet
+
+    confine do
+      find_package('puppetserver')
+    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'
+    ]
+  end
+end

data/definitions/features/puppet_server.rb

@@ -6,15 +6,11 @@ class Features::PuppetServer < ForemanMaintain::Feature
     # 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('puppetserver')
     end
   end
 
   def services
-    find_package('puppetserver') ? { 'puppetserver' => 30 } : {}
-  end
-
-  def puppet_version
-    version(execute!('puppet --version'))
+    { 'puppetserver' => 30 }
   end
 end

data/definitions/features/service.rb

@@ -0,0 +1,134 @@
+class Features::Service < ForemanMaintain::Feature
+  metadata do
+    label :service
+  end
+
+  def handle_services(spinner, action, options = {})
+    # options is used to handle "exclude" and "only" i.e.
+    # { :only => ["httpd"] }
+    # { :exclude => ["pulp-workers", "tomcat"] }
+    if feature(:downstream) && feature(:downstream).less_than_version?('6.3')
+      use_katello_service(action, options)
+    else
+      options[:reverse] = action == 'stop'
+
+      filtered_services(options).each do |service|
+        spinner.update("#{action_noun(action)} #{service}")
+        perform_action_on_service(action, service)
+      end
+
+      spinner.update("All services #{action_past_tense(action)}")
+    end
+  end
+
+  def list_services(service_list)
+    service_list = service_list.join(', ')
+    puts "#{service_list}\n"
+  end
+
+  def get_services_from_features(features)
+    features.map(&:services).
+      inject(&:merge).
+      sort_by { |_, value| value }.
+      map { |service| service[0] }
+  end
+
+  def existing_services
+    service_list = get_services_from_features(available_features)
+    service_list.select { |service| service_exists?(service) }
+  end
+
+  def filtered_services(options)
+    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
+
+  def action_noun(action)
+    action_word_modified(action) + 'ing'
+  end
+
+  def action_past_tense(action)
+    action_word_modified(action) + 'ed'
+  end
+
+  private
+
+  def available_features
+    @available_features || ForemanMaintain.available_features
+  end
+
+  def filter_services(service_list, options)
+    service_list &= options[:only] if options[:only] && options[:only].any?
+    service_list -= options[:exclude] if options[:exclude] && options[:exclude].any?
+    service_list
+  end
+
+  def perform_action_on_service(action, service)
+    command = service_command(action, service)
+    if action == 'status'
+      status = execute(command)
+      puts "\n\n#{status}\n\n"
+    else
+      execute!(command)
+    end
+  end
+
+  def service_command(action, service)
+    if File.exist?('/usr/sbin/service-wait') &&
+       !%w[enable disable].include?(action)
+      "service-wait #{service} #{action}"
+    else
+      "systemctl #{action} #{service}"
+    end
+  end
+
+  def action_word_modified(action)
+    case action
+    when 'status'
+      'display'
+    when 'enable', 'disable'
+      action.chomp('e')
+    when 'stop'
+      action + 'p'
+    else
+      action
+    end
+  end
+
+  def use_katello_service(action, options)
+    if %w[enable disable].include?(action)
+      raise 'Service enable and disable are only supported in Satellite 6.3+'
+    end
+
+    command = "katello-service #{action} "
+
+    # katello-service in 6.1 does not support --only
+    if feature(:downstream).less_than_version?('6.2')
+      excluded_services = exclude_services_only(options)
+      command += "--exclude #{excluded_services.join(',')}" if excluded_services.any?
+    else
+      command += katello_service_filters(options)
+    end
+
+    run_katello_service(command)
+  end
+
+  def run_katello_service(command)
+    puts 'Services are handled by katello-service in Satellite versions 6.2 and earlier. ' \
+         "Redirecting to: \n#{command}\n"
+    puts execute(command)
+  end
+
+  def exclude_services_only(options)
+    existing_services - filtered_services(options)
+  end
+
+  def katello_service_filters(options)
+    filters = ''
+    filters += "--exclude #{options[:exclude]}" if options[:exclude] && options[:exclude].any?
+    filters += "--only #{options[:only]}" if options[:only] && options[:only].any?
+    filters
+  end
+end