manageiq-appliance_console 1.0.0

data/lib/manageiq/appliance_console/database_replication.rb

@@ -0,0 +1,146 @@
+require 'pg'
+require 'English'
+
+module ManageIQ
+module ApplianceConsole
+  class DatabaseReplication
+    include ManageIQ::ApplianceConsole::Logging
+
+    REPMGR_CONFIG = '/etc/repmgr.conf'.freeze
+    REPMGR_LOG    = '/var/log/repmgr/repmgrd.log'.freeze
+    PGPASS_FILE   = '/var/lib/pgsql/.pgpass'.freeze
+
+    attr_accessor :cluster_name, :node_number, :database_name, :database_user,
+                  :database_password, :primary_host
+
+    def ask_for_unique_cluster_node_number
+      self.node_number = ask_for_integer("number uniquely identifying this node in the replication cluster")
+    end
+
+    def ask_for_database_credentials
+      ask_for_cluster_database_credentials
+      self.primary_host = ask_for_ip_or_hostname("primary database hostname or IP address", primary_host)
+    end
+
+    def confirm
+      clear_screen
+      say(<<-EOL)
+Replication Server Configuration
+
+        Cluster Node Number:        #{node_number}
+        Cluster Database Name:      #{database_name}
+        Cluster Database User:      #{database_user}
+        Cluster Database Password:  "********"
+        Cluster Primary Host:       #{primary_host}
+        EOL
+    end
+
+    def repmgr_configured?
+      File.exist?(REPMGR_CONFIG)
+    end
+
+    def confirm_reconfiguration
+      say("Warning: File #{REPMGR_CONFIG} exists. Replication is already configured")
+      logger.warn("Warning: File #{REPMGR_CONFIG} exists. Replication is already configured")
+      agree("Continue with configuration? (Y/N): ")
+    end
+
+    def create_config_file(host)
+      File.write(REPMGR_CONFIG, config_file_contents(host))
+      true
+    end
+
+    def config_file_contents(host)
+      <<-EOS.strip_heredoc
+        cluster=#{cluster_name}
+        node=#{node_number}
+        node_name=#{host}
+        conninfo='host=#{host} user=#{database_user} dbname=#{database_name}'
+        use_replication_slots=1
+        pg_basebackup_options='--xlog-method=stream'
+        failover=automatic
+        promote_command='repmgr standby promote'
+        follow_command='repmgr standby follow'
+        logfile=#{REPMGR_LOG}
+      EOS
+    end
+
+    def generate_cluster_name
+      begin
+        pg_conn = PG::Connection.new(primary_connection_hash)
+        primary_region_number =
+          pg_conn.exec("SELECT last_value FROM miq_databases_id_seq").first["last_value"].to_i / 1_000_000_000_000
+        self.cluster_name = "miq_region_#{primary_region_number}_cluster"
+      rescue PG::ConnectionBad => e
+        say("Failed to get primary region number #{e.message}")
+        logger.error("Failed to get primary region number #{e.message}")
+        return false
+      end
+      true
+    end
+
+    def write_pgpass_file
+      File.open(PGPASS_FILE, "w") do |f|
+        f.write("*:*:#{database_name}:#{database_user}:#{database_password}\n")
+        f.write("*:*:replication:#{database_user}:#{database_password}\n")
+      end
+
+      FileUtils.chmod(0600, PGPASS_FILE)
+      FileUtils.chown("postgres", "postgres", PGPASS_FILE)
+      true
+    end
+
+    private
+
+    def ask_for_cluster_database_credentials
+      self.database_name = just_ask("cluster database name", database_name)
+      self.database_user = just_ask("cluster database username", database_user)
+
+      count = 0
+      loop do
+        count += 1
+        password1 = ask_for_password("cluster database password", database_password)
+        # if they took the default, just bail
+        break if password1 == database_password
+        password2 = ask_for_password("cluster database password")
+        if password1 == password2
+          self.database_password = password1
+          break
+        elsif count > 1 # only reprompt password once
+          raise RuntimeError, "passwords did not match"
+        else
+          say("\nThe passwords did not match, please try again")
+        end
+      end
+    end
+
+    def run_repmgr_command(cmd, params = {})
+      pid = fork do
+        Process::UID.change_privilege(Process::UID.from_name("postgres"))
+        begin
+          res = AwesomeSpawn.run!(cmd, :params => params, :env => {"PGPASSWORD" => database_password})
+          say(res.output)
+        rescue AwesomeSpawn::CommandResultError => e
+          say(e.result.output)
+          say(e.result.error)
+          say("")
+          say("Failed to configure replication server")
+          raise
+        end
+      end
+
+      Process.wait(pid)
+      $CHILD_STATUS.success?
+    end
+
+    def primary_connection_hash
+      {
+        :dbname   => database_name,
+        :host     => primary_host,
+        :user     => database_user,
+        :password => database_password
+      }
+    end
+  end # class DatabaseReplication < DatabaseConfiguration
+end # module ApplianceConsole
+end

data/lib/manageiq/appliance_console/database_replication_primary.rb

@@ -0,0 +1,59 @@
+module ManageIQ
+module ApplianceConsole
+  class DatabaseReplicationPrimary < DatabaseReplication
+    include ManageIQ::ApplianceConsole::Logging
+
+    REGISTER_CMD = 'repmgr master register'.freeze
+
+    def initialize
+      self.cluster_name      = nil
+      self.node_number       = nil
+      self.database_name     = "vmdb_production"
+      self.database_user     = "root"
+      self.database_password = nil
+      self.primary_host      = LinuxAdmin::NetworkInterface.new(NETWORK_INTERFACE).address
+    end
+
+    def ask_questions
+      clear_screen
+      say("Establish Primary Replication Server\n")
+      ask_for_unique_cluster_node_number
+      ask_for_database_credentials
+      return false if repmgr_configured? && !confirm_reconfiguration
+      confirm
+    end
+
+    def confirm
+      super
+      agree("Apply this Replication Server Configuration? (Y/N): ")
+    end
+
+    def activate
+      say("Configuring Primary Replication Server...")
+      generate_cluster_name &&
+        create_config_file(primary_host) &&
+        initialize_primary_server &&
+        write_pgpass_file
+    end
+
+    def initialize_primary_server
+      run_repmgr_command(REGISTER_CMD) &&
+        add_repmgr_schema_to_search_path
+    end
+
+    def add_repmgr_schema_to_search_path
+      schema_name = "repmgr_#{cluster_name}"
+      begin
+        pg_conn = PG::Connection.new(primary_connection_hash)
+        new_path = pg_conn.exec("SHOW search_path").first["search_path"].split(",") << schema_name
+        pg_conn.exec("ALTER ROLE #{database_user} SET search_path = #{new_path.join(",")}")
+      rescue PG::ConnectionBad => e
+        say("Failed to add #{schema_name} to search path for #{database_user} #{e.message}")
+        logger.error("Failed to add #{schema_name} to search path for #{database_user} #{e.message}")
+        return false
+      end
+      true
+    end
+  end # class DatabaseReplicationPrimary < DatabaseReplication
+end # module ApplianceConsole
+end

data/lib/manageiq/appliance_console/database_replication_standby.rb

@@ -0,0 +1,166 @@
+require 'util/postgres_admin'
+require 'fileutils'
+require 'linux_admin'
+
+module ManageIQ
+module ApplianceConsole
+  class DatabaseReplicationStandby < DatabaseReplication
+    include ManageIQ::ApplianceConsole::Logging
+
+    REGISTER_CMD    = 'repmgr standby register'.freeze
+    REPMGRD_SERVICE = 'rh-postgresql95-repmgr'.freeze
+
+    attr_accessor :disk, :standby_host, :run_repmgrd_configuration, :resync_data, :force_register
+
+    def initialize
+      self.cluster_name      = nil
+      self.node_number       = nil
+      self.database_name     = "vmdb_production"
+      self.database_user     = "root"
+      self.database_password = nil
+      self.primary_host      = nil
+      self.standby_host      = LinuxAdmin::NetworkInterface.new(NETWORK_INTERFACE).address
+      self.resync_data       = false
+    end
+
+    def ask_questions
+      clear_screen
+      say("Establish Replication Standby Server\n")
+      return false if !data_dir_empty? && !confirm_data_resync
+      self.disk = ask_for_disk("Standby database disk")
+      ask_for_unique_cluster_node_number
+      ask_for_database_credentials
+      ask_for_standby_host
+      ask_for_repmgrd_configuration
+      return false unless node_number_valid?
+      return false if repmgr_configured? && !confirm_reconfiguration
+      confirm
+    end
+
+    def confirm
+      super
+      say(<<-EOS) if disk
+        Database Disk:              #{disk.path}
+      EOS
+      say(<<-EOS)
+        Standby Host:               #{standby_host}
+        Automatic Failover:         #{run_repmgrd_configuration ? "enabled" : "disabled"}
+      EOS
+      agree("Apply this Replication Server Configuration? (Y/N): ")
+    end
+
+    def ask_for_standby_host
+      self.standby_host = ask_for_ip_or_hostname("Standby Server hostname or IP address", standby_host)
+    end
+
+    def ask_for_repmgrd_configuration
+      self.run_repmgrd_configuration = ask_yn?("Configure Replication Manager (repmgrd) for automatic failover")
+    end
+
+    def activate
+      say("Configuring Replication Standby Server...")
+      stop_postgres
+      stop_repmgrd
+      initialize_postgresql_disk if disk
+      PostgresAdmin.prep_data_directory if disk || resync_data
+      generate_cluster_name &&
+        create_config_file(standby_host) &&
+        clone_standby_server &&
+        start_postgres &&
+        register_standby_server &&
+        write_pgpass_file &&
+        (run_repmgrd_configuration ? start_repmgrd : true)
+    end
+
+    def data_dir_empty?
+      Dir[PostgresAdmin.data_directory.join("*")].empty?
+    end
+
+    def confirm_data_resync
+      logger.info("Appliance database found under: #{PostgresAdmin.data_directory}")
+      say("")
+      say("Appliance database found under: #{PostgresAdmin.data_directory}")
+      say("Replication standby server can not be configured if the database already exists")
+      say("Would you like to remove the existing database before configuring as a standby server?")
+      say("  WARNING: This is destructive. This will remove all previous data from this server")
+      self.resync_data = ask_yn?("Continue")
+    end
+
+    def clone_standby_server
+      params = { :h  => primary_host,
+                 :U  => database_user,
+                 :d  => database_name,
+                 :D  => PostgresAdmin.data_directory,
+                 nil => %w(standby clone)
+               }
+      run_repmgr_command("repmgr", params)
+    end
+
+    def start_postgres
+      LinuxAdmin::Service.new(PostgresAdmin.service_name).enable.start
+      true
+    end
+
+    def stop_postgres
+      LinuxAdmin::Service.new(PostgresAdmin.service_name).stop
+      true
+    end
+
+    def register_standby_server
+      run_repmgr_command(REGISTER_CMD, :force => nil)
+    end
+
+    def start_repmgrd
+      LinuxAdmin::Service.new(REPMGRD_SERVICE).enable.start
+      true
+    rescue AwesomeSpawn::CommandResultError => e
+      message = "Failed to start repmgrd: #{e.message}"
+      logger.error(message)
+      say(message)
+      false
+    end
+
+    def stop_repmgrd
+      LinuxAdmin::Service.new(REPMGRD_SERVICE).stop
+      true
+    end
+
+    def node_number_valid?
+      rec = record_for_node_number
+
+      return true if rec.nil?
+      node_state = rec["active"] ? "active" : "inactive"
+
+      say("An #{node_state} #{rec["type"]} node (#{rec["name"]}) with the node number #{node_number} already exists")
+      ask_yn?("Would you like to continue configuration by overwriting the existing node", "N")
+
+    rescue PG::Error => e
+      error_msg = "Failed to validate node number #{node_number}. #{e.message}"
+      say(error_msg)
+      logger.error(error_msg)
+      return false
+    end
+
+    private
+
+    def record_for_node_number
+      c = PG::Connection.new(primary_connection_hash)
+      c.exec_params(<<-SQL, [node_number]).map_types!(PG::BasicTypeMapForResults.new(c)).first
+        SELECT type, name, active
+        FROM repl_nodes where id = $1
+      SQL
+    end
+
+    def initialize_postgresql_disk
+      log_and_feedback(__method__) do
+        LogicalVolumeManagement.new(:disk                => disk,
+                                    :mount_point         => PostgresAdmin.mount_point,
+                                    :name                => "pg",
+                                    :volume_group_name   => PostgresAdmin.volume_group_name,
+                                    :filesystem_type     => PostgresAdmin.database_disk_filesystem,
+                                    :logical_volume_path => PostgresAdmin.logical_volume_path).setup
+      end
+    end
+  end # class DatabaseReplicationStandby < DatabaseReplication
+end # module ApplianceConsole
+end

data/lib/manageiq/appliance_console/date_time_configuration.rb

@@ -0,0 +1,117 @@
+module ManageIQ
+module ApplianceConsole
+  class DateTimeConfiguration
+    DATE_REGEXP   = /^(2[0-9]{3})-(0?[1-9]|1[0-2])-(0?[1-9]|[12][0-9]|3[01])/
+    DATE_PROMPT   = "current date (YYYY-MM-DD)".freeze
+    TIME_REGEXP   = /^(0?[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])/
+    TIME_PROMPT   = "current time in 24 hour format (HH:MM:SS)".freeze
+
+    attr_accessor :new_date, :new_time, :manual_time_sync
+
+    include ManageIQ::ApplianceConsole::Logging
+
+    def initialize
+      @new_date         = nil
+      @new_time         = nil
+      @manual_time_sync = false
+    end
+
+    def activate
+      say("Applying time configuration...")
+      establish_auto_sync &&
+        configure_date_time
+    end
+
+    def ask_questions
+      ask_establish_auto_sync
+      ask_for_date &&
+        ask_for_time &&
+        confirm
+    end
+
+    def ask_establish_auto_sync
+      say("Automatic time synchronization must be disabled to manually set date or time\n\n")
+
+      @manual_time_sync = agree(<<-EOL)
+Yes to disable Automatic time synchronization and prompt for date and time.
+ No to enable  Automatic time synchronization.  (Y/N):
+
+        EOL
+    end
+
+    def ask_for_date
+      return true unless manual_time_sync
+      @new_date = just_ask(DATE_PROMPT, nil, DATE_REGEXP)
+      true
+    rescue
+      false
+    end
+
+    def ask_for_time
+      return true unless manual_time_sync
+      @new_time = just_ask(TIME_PROMPT, nil, TIME_REGEXP)
+      true
+    rescue
+      false
+    end
+
+    def confirm
+      manual_time_sync ? confirm_manual : confirm_auto
+    end
+
+    def confirm_auto
+      clear_screen
+      say("Date and Time Configuration will be automatic")
+
+      agree("Apply automatic time configuration? (Y/N): ")
+    end
+
+    def confirm_manual
+      clear_screen
+      say(<<-EOL)
+Date and Time Configuration
+
+        Date: #{new_date}
+        Time: #{new_time}
+
+        EOL
+
+      agree("Apply manual time configuration? (Y/N): ")
+    end
+
+    def establish_auto_sync
+      manual_time_sync ? disable_auto_sync : enable_auto_sync
+    end
+
+    def enable_auto_sync
+      LinuxAdmin::Service.new("chronyd").enable.start
+      LinuxAdmin::Service.new("systemd-timedated").restart
+      true
+    rescue => e
+      say("Failed to enable time synchronization")
+      logger.error("Failed to enable time synchronization: #{e.message}")
+      false
+    end
+
+    def disable_auto_sync
+      LinuxAdmin::Service.new("chronyd").stop.disable
+      LinuxAdmin::Service.new("systemd-timedated").restart
+      true
+    rescue => e
+      say("Failed to disable time synchronization")
+      logger.error("Failed to disable time synchronization: #{e.message}")
+      false
+    end
+
+    def configure_date_time
+      return true unless manual_time_sync
+      LinuxAdmin::TimeDate.system_time = Time.parse("#{new_date} #{new_time}").getlocal
+      true
+    rescue => e
+      say("Failed to apply time configuration")
+      logger.error("Failed to apply time configuration: #{e.message}")
+      false
+    end
+  end # class TimezoneConfiguration
+end # module ApplianceConsole
+end