foreman_maintain 0.1.6 → 0.2.0

data/definitions/features/foreman_proxy.rb

@@ -17,12 +17,73 @@ class Features::ForemanProxy < ForemanMaintain::Feature
     dhcp_req_pass? && !syntax_error_exists?
   end
 
+  def services
+    {
+      'foreman-proxy'            => 20,
+      'smart_proxy_dynflow_core' => 20
+    }
+  end
+
+  def features
+    # TODO: handle failures
+    run_curl_cmd("#{curl_cmd}/features").result
+  end
+
+  def internal?
+    !!feature(:foreman_server)
+  end
+
+  def config_files(for_features = ['all'])
+    configs = [
+      '/etc/foreman-proxy',
+      '/usr/share/foreman-proxy/.ssh/',
+      '/etc/smart_proxy_dynflow_core/settings.yml',
+      '/etc/sudoers.d/foreman-proxy'
+    ]
+    backup_features = backup_features(for_features)
+
+    configs.push(certs_tar) if certs_tar
+
+    configs.push('/var/lib/tftpboot') if backup_features.include?('tftp')
+    configs += ['/var/named/', '/etc/named*'] if backup_features.include?('dns')
+    configs += ['/var/lib/dhcpd', '/etc/dhcp'] if backup_features.include?('dhcp')
+    configs.push('/usr/share/xml/scap') if backup_features.include?('openscap')
+    configs
+  end
+
+  def content_module
+    return @content_module if @content_module_detected
+    @content_module_detected = true
+    answer = feature(:installer).answers.find do |_, config|
+      config.is_a?(Hash) && config.key?('certs_tar')
+    end
+    @content_module = answer.nil? ? 'foreman_proxy_content' : answer.first
+    logger.debug("foreman proxy content module detected: #{@content_module}")
+    @content_module
+  end
+
+  def certs_tar
+    feature(:installer).answers[content_module]['certs_tar'] if content_module
+  end
+
   private
 
-  def dhcp_curl_cmd
+  def backup_features(for_features)
+    full_features = features
+    backup_features = for_features.include?('all') ? full_features : (full_features & for_features)
+    logger.info("Proxy features: #{full_features}")
+    logger.info("Proxy features to backup: #{backup_features}")
+    backup_features
+  end
+
+  def curl_cmd
     "curl -w '\n%{http_code}' --silent -ks --cert #{cert_path}/client_cert.pem \
       --key #{cert_path}/client_key.pem \
-      --cacert #{cert_path}/proxy_ca.pem https://$(hostname):9090/dhcp"
+      --cacert #{cert_path}/proxy_ca.pem https://$(hostname):9090"
+  end
+
+  def dhcp_curl_cmd
+    "#{curl_cmd}/dhcp"
   end
 
   def find_http_error_msg(array_output, curl_http_status)
@@ -34,13 +95,15 @@ class Features::ForemanProxy < ForemanMaintain::Feature
         next unless str.include?('HTTP')
         http_line = str
       end
-      return http_line if http_line.empty?
-      http_line.split(curl_http_status.to_s).last.strip
+      msg = http_line.split(curl_http_status.to_s).last
+      msg = msg.strip unless msg.nil?
+      msg
     end
   end
 
-  def run_dhcp_curl
-    curl_resp = execute(dhcp_curl_cmd)
+  def run_curl_cmd(cmd)
+    # TODO: consider Net::HTTP instead of curl
+    curl_resp = execute(cmd)
     array_output = curl_resp.split(/\r?\n/)
     status_str = array_output.last
     curl_http_status = (status_str ? status_str.strip : status_str).to_i
@@ -53,7 +116,7 @@ class Features::ForemanProxy < ForemanMaintain::Feature
   end
 
   def dhcp_req_pass?
-    dhcp_curl_resp = run_dhcp_curl
+    dhcp_curl_resp = run_curl_cmd(dhcp_curl_cmd)
     success = true
     if dhcp_curl_resp.http_code.eql?(200)
       if dhcp_curl_resp.result.to_s.empty?

data/definitions/features/foreman_server.rb

@@ -7,6 +7,35 @@ module ForemanMaintain
           server?
         end
       end
+
+      def services
+        {
+          'postgresql'               => 5,
+          'httpd'                    => 30
+        }
+      end
+
+      def plugins
+        list_cmd = "export RUBYOPT='-W0'; foreman-rake plugin:list| grep 'Foreman plugin: '"
+        plugin_list = execute(list_cmd).lines
+        plugin_list.map do |line|
+          plugin = line.split
+          "#{plugin[2].chop}-#{plugin[3].chop}"
+        end
+      end
+
+      def config_files
+        [
+          '/etc/httpd',
+          '/var/www/html/pub',
+          '/etc/squid',
+          '/etc/foreman',
+          '/etc/selinux/targeted/contexts/files/file_contexts.subs',
+          '/etc/sysconfig/foreman',
+          '/usr/share/ruby/vendor_ruby/puppet/reports/foreman.rb',
+          '/var/lib/foreman'
+        ]
+      end
     end
   end
 end

data/definitions/features/foreman_tasks.rb

@@ -95,7 +95,7 @@ class Features::ForemanTasks < ForemanMaintain::Feature
   end
 
   def resume_task_using_hammer
-    hammer('task resume')
+    feature(:hammer).run('task resume')
   end
 
   def fetch_tasks_status(state, spinner)
@@ -107,6 +107,10 @@ class Features::ForemanTasks < ForemanMaintain::Feature
     puts "\nTimeout: #{e.message}. Try again."
   end
 
+  def services
+    { 'foreman-tasks' => 30 }
+  end
+
   private
 
   def check_task_count(state, spinner)

data/definitions/features/hammer.rb

@@ -1,6 +1,14 @@
+require 'uri'
+
 class Features::Hammer < ForemanMaintain::Feature
+  attr_reader :configuration, :config_files
+
   metadata do
     label :hammer
+    confine do
+      # FIXME: How does this run on proxy?
+      find_package('rubygem-hammer_cli') || find_package('tfm-rubygem-hammer_cli')
+    end
   end
 
   SERVICES_MAPPING = {
@@ -11,6 +19,32 @@ class Features::Hammer < ForemanMaintain::Feature
     'foreman_tasks' => %w[foreman-tasks]
   }.freeze
 
+  def initialize
+    @configuration = { :foreman => {} }
+    @config_files = []
+    @ready = nil
+    load_configuration
+  end
+
+  def config_directories
+    [
+      '~/.hammer/',
+      '/etc/hammer/'
+    ]
+  end
+
+  def setup_admin_access
+    return true if check_connection
+    logger.info('Hammer setup is not valid. Fixing configuration.')
+    custom_config = { :foreman => { :username => 'admin' } }
+    custom_config = on_invalid_host(custom_config)
+    custom_config = on_missing_password(custom_config) # get password from answers
+    custom_config = on_invalid_password(custom_config) # get password from answers
+    ask_password_and_check(custom_config) unless ready?
+    config_error unless ready?
+    ready?
+  end
+
   def hammer_ping_cmd
     cmd_output = exec_hammer_cmd('--output json ping', true)
     return init_result_obj(false, cmd_output) if cmd_output.is_a?(String)
@@ -21,6 +55,88 @@ class Features::Hammer < ForemanMaintain::Feature
     init_result_obj(false, msg_to_show, services)
   end
 
+  def ready?
+    setup_admin_access if @ready.nil?
+    @ready
+  end
+
+  def check_connection
+    @ready = _check_connection
+  end
+
+  def server_uri
+    "https://#{hostname}/"
+  end
+
+  def custom_config_file
+    fm_config_dir = File.dirname(ForemanMaintain.config_file)
+    File.join(fm_config_dir, 'foreman-maintain-hammer.yml')
+  end
+
+  def command_base
+    if File.exist?(custom_config_file)
+      %(RUBYOPT='-W0' LANG=en_US.utf-8 hammer -c "#{custom_config_file}" --interactive=no)
+    else
+      %(RUBYOPT='-W0' LANG=en_US.utf-8 hammer --interactive=no)
+    end
+  end
+
+  # Run a hammer command, examples:
+  # run('host list')
+  def run(args)
+    setup_admin_access
+    execute("#{command_base} #{args}")
+  end
+
+  private
+
+  def on_invalid_host(custom_config)
+    hammer_host = URI.parse(configuration[:foreman][:host]).host if configuration[:foreman][:host]
+    if hammer_host != hostname
+      logger.info("Matching hostname was not found in hammer configs. Using #{server_uri}")
+      custom_config[:foreman][:host] = server_uri
+    end
+    custom_config
+  end
+
+  def on_invalid_password(custom_config)
+    if !ready? && custom_config[:foreman][:password].nil?
+      msg = 'Invalid admin password was found in hammer configs. Looking into installer answers'
+      logger.info(msg)
+      custom_config[:foreman][:password] = password_from_answers
+      save_config_and_check(custom_config)
+    end
+    custom_config
+  end
+
+  def ask_password_and_check(custom_config)
+    custom_config[:foreman][:password] = ask('Hammer admin password:', :password => true)
+    save_config_and_check(custom_config)
+    custom_config
+  end
+
+  def config_error
+    raise ForemanMaintain::HammerConfigurationError, 'Hammer configuration failed: '\
+                  "Is the admin password correct? (it was stored in #{custom_config_file})" \
+                  'Is the server down?'
+  end
+
+  def on_missing_password(custom_config)
+    if admin_password_missing?
+      msg = 'Admin password was not found in hammer configs. Looking into installer answers'
+      logger.info(msg)
+      custom_config[:foreman][:password] = password_from_answers
+    end
+    save_config_and_check(custom_config)
+    custom_config
+  end
+
+  def admin_password_missing?
+    configuration[:foreman][:password].nil? ||
+      configuration[:foreman][:password].empty? ||
+      configuration[:foreman][:username] != 'admin'
+  end
+
   def find_resources_which_failed(hammer_ping_output)
     resources_failed = []
     hammer_ping_output.each do |resource, resp_obj|
@@ -29,8 +145,6 @@ class Features::Hammer < ForemanMaintain::Feature
     resources_failed
   end
 
-  private
-
   def map_resources_with_services(resources)
     service_names = []
     resources.each do |resource|
@@ -48,8 +162,49 @@ class Features::Hammer < ForemanMaintain::Feature
   end
 
   def exec_hammer_cmd(cmd, required_json = false)
-    response = ForemanMaintain::Utils::Hammer.instance.run_command(cmd)
+    response = run(cmd)
     json_str = parse_json(response) if required_json
     json_str ? json_str : response
   end
+
+  def load_configuration
+    config_directories.reverse.each do |path|
+      full_path = File.expand_path path
+      next unless File.directory? full_path
+      load_from_file(File.join(full_path, 'cli_config.yml'))
+      load_from_file(File.join(full_path, 'defaults.yml'))
+      # load config for modules
+      Dir.glob(File.join(full_path, 'cli.modules.d/*.yml')).sort.each do |f|
+        load_from_file(f)
+      end
+    end
+  end
+
+  def load_from_file(file_path)
+    if File.file? file_path
+      config = YAML.load(File.open(file_path))
+      if config
+        ForemanMaintain::Utils::HashTools.deep_merge!(@configuration, config)
+        @config_files << file_path
+      end
+    end
+  end
+
+  def password_from_answers
+    return nil unless feature(:installer)
+    feature(:installer).answers['foreman']['admin_password']
+  end
+
+  def save_config_and_check(config)
+    save_config(config)
+    check_connection
+  end
+
+  def save_config(config)
+    File.open(custom_config_file, 'w', 0o600) { |f| f.puts YAML.dump(config) }
+  end
+
+  def _check_connection
+    `#{command_base} architecture list 2>&1` && $CHILD_STATUS.exitstatus == 0
+  end
 end

data/definitions/features/installer.rb

@@ -0,0 +1,106 @@
+class Features::Installer < ForemanMaintain::Feature
+  metadata do
+    label :installer
+
+    confine do
+      find_package('foreman-installer') ||
+        find_package('katello-installer') ||
+        find_package('capsule-installer')
+    end
+  end
+
+  def initialize
+    @installer_type = if find_package('foreman-installer')
+                        :scenarios
+                      elsif find_package('katello-installer')
+                        :legacy_katello
+                      elsif find_package('capsule-installer')
+                        :legacy_capsule
+                      end
+  end
+
+  def answers
+    case @installer_type
+    when :scenarios
+      last_scenario_answers
+    when :legacy_katello
+      load_answers(File.join(config_directory, 'katello-installer.yaml'))
+    when :legacy_capsule
+      load_answers(File.join(config_directory, 'capsule-installer.yaml'))
+    end
+  end
+
+  def with_scenarios?
+    @installer_type == :scenarios
+  end
+
+  def config_directory
+    case @installer_type
+    when :scenarios
+      '/etc/foreman-installer'
+    when :legacy_katello
+      '/etc/katello-installer'
+    when :legacy_capsule
+      '/etc/capsule-installer'
+    end
+  end
+
+  def can_upgrade?
+    @installer_type == :scenarios || @installer_type == :legacy_katello
+  end
+
+  def config_files
+    Dir.glob(File.join(config_directory, '**/*')) +
+      [
+        '/usr/local/bin/validate_postgresql_connection.sh'
+      ]
+  end
+
+  def last_scenario
+    return nil unless with_scenarios?
+    File.basename(last_scenario_config).split('.')[0]
+  end
+
+  def installer_command
+    case @installer_type
+    when :scenarios
+      if feature(:downstream)
+        'satellite-installer'
+      else
+        'foreman-installer'
+      end
+    when :legacy_katello
+      'katello-installer'
+    when :legacy_capsule
+      'capsule-installer'
+    end
+  end
+
+  def run(arguments = '', exec_options = {})
+    execute!("LANG=en_US.utf-8 #{installer_command} #{arguments}".strip, exec_options)
+  end
+
+  def upgrade(exec_options = {})
+    arguments = '--upgrade' if can_upgrade?
+    run(arguments, exec_options)
+  end
+
+  private
+
+  def load_answers(config_file)
+    config = YAML.load_file(config_file)
+    YAML.load_file(config[:answer_file])
+  end
+
+  def scenario_answers(scenario)
+    load_answers(File.join(config_directory, "scenarios.d/#{scenario}.yaml"))
+  end
+
+  def last_scenario_answers
+    scenario_answers(last_scenario)
+  end
+
+  def last_scenario_config
+    Pathname.new(File.join(config_directory, 'scenarios.d/last_scenario.yaml')).realpath.to_s
+  end
+end