manageiq-appliance_console 1.0.0

data/lib/manageiq/appliance_console/database_configuration.rb

@@ -0,0 +1,286 @@
+require 'active_record'
+require 'active_support/core_ext'
+require 'linux_admin'
+require 'pathname'
+require 'util/miq-password'
+require 'fileutils'
+
+module ManageIQ
+module ApplianceConsole
+  class DatabaseConfiguration
+    attr_accessor :adapter, :host, :username, :database, :password, :port, :region
+
+    class ModelWithNoBackingTable < ActiveRecord::Base
+    end
+
+    DB_YML      = ManageIQ::ApplianceConsole::RAILS_ROOT.join("config/database.yml")
+    DB_YML_TMPL = ManageIQ::ApplianceConsole::RAILS_ROOT.join("config/database.pg.yml")
+
+    CREATE_REGION_AGREE = "WARNING: Creating a database region will destroy any existing data and cannot be undone.\n\nAre you sure you want to continue? (Y/N):".freeze
+    FAILED_WITH_ERROR_HYPHEN = "failed with error -".freeze
+
+    # PG 9.2 bigint max 9223372036854775807 / ArRegion::DEFAULT_RAILS_SEQUENCE_FACTOR = 9223372
+    # http://www.postgresql.org/docs/9.2/static/datatype-numeric.html
+    # 9223372 won't be a full region though, so we're not including it.
+    # TODO: This information should be shared outside of appliance console code and MiqRegion.
+    REGION_RANGE = 0..9223371
+    DEFAULT_PORT = 5432
+
+    include ManageIQ::ApplianceConsole::Logging
+
+    def initialize(hash = {})
+      initialize_from_hash(hash)
+      @adapter ||= "postgresql"
+      # introduced by Logging
+      self.interactive = true unless hash.key?(:interactive)
+    end
+
+    def run_interactive
+      ask_questions
+
+      clear_screen
+      say "Activating the configuration using the following settings...\n#{friendly_inspect}\n"
+
+      raise MiqSignalError unless activate
+
+      post_activation
+      say("\nConfiguration activated successfully.\n")
+    rescue RuntimeError => e
+      puts "Configuration failed#{": " + e.message unless e.class == MiqSignalError}"
+      press_any_key
+      raise MiqSignalError
+    end
+
+    def local?
+      host.blank? || host.in?(%w(localhost 127.0.0.1))
+    end
+
+    def password=(value)
+      @password = MiqPassword.try_decrypt(value)
+    end
+
+    def activate
+      return false unless validated
+
+      original = self.class.current
+      success  = false
+
+      begin
+        save
+        success = create_or_join_region
+      rescue
+        success = false
+      ensure
+        save(original) unless success
+      end
+    end
+
+    def create_or_join_region
+      region ? create_region : join_region
+    end
+
+    def create_region
+      ManageIQ::ApplianceConsole::Utilities.bail_if_db_connections("preventing the setup of a database region")
+      log_and_feedback(__method__) do
+        ManageIQ::ApplianceConsole::Utilities.rake("evm:db:region", ["--", {:region => region}])
+      end
+    end
+
+    def join_region
+      ManageIQ::ApplianceConsole::Utilities.rake("evm:join_region", {})
+    end
+
+    def reset_region
+      say("Warning: RESETTING A DATABASE WILL DESTROY ANY EXISTING DATA AND CANNOT BE UNDONE.\n\n")
+      raise MiqSignalError unless are_you_sure?("reset the configured database")
+
+      create_new_region_questions(false)
+      ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"] = "1"
+      create_region
+    ensure
+      ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"] = nil
+    end
+
+    def create_new_region_questions(warn = true)
+      clear_screen
+      say("\n\nNote: Creating a new database region requires an empty database.") if warn
+      say("Each database region number must be unique.\n")
+      self.region = ask_for_integer("database region number", REGION_RANGE)
+      raise MiqSignalError if warn && !agree(CREATE_REGION_AGREE)
+    end
+
+    def ask_for_database_credentials(password_twice = true)
+      self.host     = ask_for_ip_or_hostname("database hostname or IP address", host) if host.blank? || !local?
+      self.port     = ask_for_integer("port number", nil, port) unless local?
+      self.database = just_ask("name of the database on #{host}", database) unless local?
+      self.username = just_ask("username", username) unless local?
+      count = 0
+      loop do
+        password1 = ask_for_password("database password on #{host}", password)
+        # if they took the default, just bail
+        break if (password1 == password)
+
+        if password1.strip.length == 0
+          say("\nPassword can not be empty, please try again")
+          next
+        end
+        if password_twice
+          password2 = ask_for_password("database password again")
+          if password1 == password2
+            self.password = password1
+            break
+          elsif count > 0 # only reprompt password once
+            raise "passwords did not match"
+          else
+            count += 1
+            say("\nThe passwords did not match, please try again")
+          end
+        else
+          self.password = password1
+          break
+        end
+      end
+    end
+
+    def friendly_inspect
+      output = <<-FRIENDLY
+Host:     #{host}
+Username: #{username}
+Database: #{database}
+FRIENDLY
+      output << "Port:     #{port}\n" if port
+      output << "Region:   #{region}\n" if region
+      output
+    end
+
+    def settings_hash
+      {
+        'adapter'  => 'postgresql',
+        'host'     => local? ? "localhost" : host,
+        'port'     => port,
+        'username' => username,
+        'password' => password.presence,
+        'database' => database
+      }
+    end
+
+    # merge all the non specified setings
+    # for all the basic attributes, overwrite from this object (including blank values)
+    def merged_settings
+      merged = self.class.current
+      settings_hash.each do |k, v|
+        if v.present?
+          merged['production'][k] = v
+        else
+          merged['production'].delete(k)
+        end
+      end
+      merged
+    end
+
+    def save(settings = nil)
+      settings ||= merged_settings
+      settings = self.class.encrypt_password(settings)
+      do_save(settings)
+    end
+
+    def self.encrypt_password(settings)
+      encrypt_decrypt_password(settings) { |pass| MiqPassword.try_encrypt(pass) }
+    end
+
+    def self.decrypt_password(settings)
+      encrypt_decrypt_password(settings) { |pass| MiqPassword.try_decrypt(pass) }
+    end
+
+    def self.current
+      decrypt_password(load_current)
+    end
+
+    def self.database_yml_configured?
+      File.exist?(DB_YML) && File.exist?(KEY_FILE)
+    end
+
+    def self.database_host
+      database_yml_configured? ? current[rails_env]['host'] || "localhost" : nil
+    end
+
+    def self.database_name
+      database_yml_configured? ? current[rails_env]['database'] : nil
+    end
+
+    def self.region
+      database_yml_configured? ? ManageIQ::ApplianceConsole::Utilities.db_region : nil
+    end
+
+    def validated
+      !!validate!
+    rescue => err
+      say_error(__method__, err.message)
+      log_error(__method__, err.message)
+      false
+    end
+
+    def validate!
+      pool = ModelWithNoBackingTable.establish_connection(settings_hash.delete_if { |_n, v| v.blank? })
+      begin
+        pool.connection
+      ensure
+        ModelWithNoBackingTable.remove_connection
+      end
+    end
+
+    def start_evm
+      pid = fork do
+        begin
+          LinuxAdmin::Service.new("evmserverd").enable.start
+        rescue => e
+          logger.error("Failed to enable and start evmserverd service: #{e.message}")
+          logger.error(e.backtrace.join("\n"))
+        end
+      end
+      Process.detach(pid)
+    end
+
+    private
+
+    def self.rails_env
+      ENV["RAILS_ENV"] || "development"
+    end
+    private_class_method :rails_env
+
+    def self.encrypt_decrypt_password(settings)
+      new_settings = {}
+      settings.each_key { |section| new_settings[section] = settings[section].dup }
+      pass = new_settings["production"]["password"]
+      new_settings["production"]["password"] = yield(pass) if pass
+      new_settings
+    end
+
+    def self.load_current
+      require 'yaml'
+      unless File.exist?(DB_YML)
+        require 'fileutils'
+        FileUtils.cp(DB_YML_TMPL, DB_YML) if File.exist?(DB_YML_TMPL)
+      end
+      YAML.load_file(DB_YML)
+    end
+
+    def do_save(settings)
+      require 'yaml'
+      File.write(DB_YML, YAML.dump(settings))
+    end
+
+    def initialize_from_hash(hash)
+      hash.each do |k, v|
+        next if v.nil?
+        setter = "#{k}="
+        if self.respond_to?(setter)
+          public_send(setter, v)
+        else
+          raise ArgumentError, "Invalid argument: #{k}"
+        end
+      end
+    end
+  end
+end
+end

data/lib/manageiq/appliance_console/database_maintenance.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module ManageIQ
+module ApplianceConsole
+  class DatabaseMaintenance
+    include ManageIQ::ApplianceConsole::Logging
+
+    attr_accessor :hourly, :executed_hourly_action, :requested_hourly_action
+    attr_accessor :periodic, :executed_periodic_action, :requested_periodic_action
+
+    def initialize
+      self.hourly   = ManageIQ::ApplianceConsole::DatabaseMaintenanceHourly.new
+      self.periodic = ManageIQ::ApplianceConsole::DatabaseMaintenancePeriodic.new
+      self.requested_hourly_action = false
+      self.requested_periodic_action = false
+      self.executed_hourly_action = false
+      self.executed_periodic_action = false
+    end
+
+    def ask_questions
+      clear_screen
+      self.requested_hourly_action = hourly.confirm
+      self.requested_periodic_action = periodic.confirm
+      requested_hourly_action || requested_periodic_action
+    end
+
+    def activate
+      say("Configuring Database Maintenance...")
+      self.executed_hourly_action = hourly.activate
+      self.executed_periodic_action = periodic.activate
+      executed_hourly_action || executed_periodic_action
+    end
+  end # class DatabaseMaintenance < DatabaseConfiguration
+end # module ApplianceConsole
+end

data/lib/manageiq/appliance_console/database_maintenance_hourly.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+module ManageIQ
+module ApplianceConsole
+  class DatabaseMaintenanceHourly
+    include ManageIQ::ApplianceConsole::Logging
+
+    HOURLY_CRON = "/etc/cron.hourly/miq-pg-maintenance-hourly.cron".freeze
+
+    attr_accessor :already_configured, :requested_deactivate, :requested_activate
+
+    def initialize
+      self.already_configured = File.exist?(HOURLY_CRON)
+      self.requested_deactivate = false
+      self.requested_activate = false
+    end
+
+    def activate
+      return deactivate if requested_deactivate
+      return configure if requested_activate
+      false
+    end
+
+    def confirm
+      if already_configured
+        self.requested_deactivate = agree("Hourly Database Maintenance is already configured, Un-Configure (Y/N):")
+      else
+        self.requested_activate = agree("Configure Hourly Database Maintenance? (Y/N): ")
+      end
+    end
+
+    private
+
+    def configure
+      say("Configuring Hourly Database Maintenance...")
+      write_hourly_cron
+      FileUtils.chmod(0755, HOURLY_CRON)
+      true
+    end
+
+    def deactivate
+      say("Un-Configuring Hourly Database Maintenance...")
+      FileUtils.rm_f(HOURLY_CRON)
+      true
+    end
+
+    def write_hourly_cron
+      File.open(HOURLY_CRON, "w") do |f|
+        f.write("#!/bin/sh\n")
+        f.write("/usr/bin/hourly_reindex_metrics_tables\n")
+        f.write("/usr/bin/hourly_reindex_miq_queue_table\n")
+        f.write("/usr/bin/hourly_reindex_miq_workers_table\n")
+        f.write("exit 0\n")
+      end
+    end
+  end # class DatabaseMaintenance < DatabaseConfiguration
+end # module ApplianceConsole
+end

data/lib/manageiq/appliance_console/database_maintenance_periodic.rb

@@ -0,0 +1,84 @@
+module ManageIQ
+module ApplianceConsole
+  class DatabaseMaintenancePeriodic
+    include ManageIQ::ApplianceConsole::Logging
+
+    RUN_AS           = 'root'.freeze
+    PERIODIC_CMD     = '/usr/bin/periodic_vacuum_full_tables'.freeze
+    CRONTAB_FILE     = '/etc/crontab'.freeze
+    SCHEDULE_PROMPT  = 'frequency periodic database maintenance should run (hourly daily weekly monthly)'.freeze
+    HOUR_PROMPT      = 'hour number (0..23)'.freeze
+    WEEK_DAY_PROMPT  = 'week day number (0..6, where Sunday is 0)'.freeze
+    MONTH_DAY_PROMPT = 'month day number (1..31)'.freeze
+
+    attr_accessor :crontab_schedule_expression, :already_configured, :requested_deactivate, :requested_activate
+
+    def initialize
+      self.crontab_schedule_expression = nil
+      self.already_configured = File.readlines(CRONTAB_FILE).detect { |line| line =~ /#{PERIODIC_CMD}/ }.present?
+      self.requested_deactivate = false
+      self.requested_activate = false
+    end
+
+    def activate
+      return deactivate if requested_deactivate
+      return configure if requested_activate
+      false
+    end
+
+    def confirm
+      if already_configured
+        self.requested_deactivate = agree("Periodic Database Maintenance is already configured, Un-Configure (Y/N):")
+      else
+        self.requested_activate = agree("Configure Periodic Database Maintenance? (Y/N): ")
+        ask_for_schedule if requested_activate
+      end
+    end
+
+    private
+
+    def ask_for_schedule
+      self.crontab_schedule_expression =
+        case ask_for_schedule_frequency(SCHEDULE_PROMPT, 'monthly')
+        when 'hourly'
+          generate_hourly_crontab_expression
+        when 'daily'
+          generate_daily_crontab_expression
+        when 'weekly'
+          generate_weekly_crontab_expression
+        when 'monthly'
+          generate_monthly_crontab_expression
+        end
+    end
+
+    def configure
+      File.open(CRONTAB_FILE, "a") do |f|
+        f.write("#{crontab_schedule_expression} #{RUN_AS} #{PERIODIC_CMD}\n")
+      end
+      true
+    end
+
+    def deactivate
+      keep_content = File.readlines(CRONTAB_FILE).reject { |line| line =~ /#{PERIODIC_CMD}/ }
+      File.open(CRONTAB_FILE, "w") { |f| keep_content.each { |line| f.puts line } }
+      true
+    end
+
+    def generate_hourly_crontab_expression
+      "0 * * * *"
+    end
+
+    def generate_daily_crontab_expression
+      "0 #{ask_for_hour_number(HOUR_PROMPT)} * * *"
+    end
+
+    def generate_weekly_crontab_expression
+      "0 #{ask_for_hour_number(HOUR_PROMPT)} * * #{ask_for_week_day_number(WEEK_DAY_PROMPT)}"
+    end
+
+    def generate_monthly_crontab_expression
+      "0 #{ask_for_hour_number(HOUR_PROMPT)} #{ask_for_month_day_number(MONTH_DAY_PROMPT)} * *"
+    end
+  end # class DatabaseMaintenancePeriodic
+end # module ApplianceConsole
+end