class ManageIQ::ApplianceConsole::PostgresAdmin

Constants

BASE_BACKUP_MAGIC
GC_AGGRESSIVE_DEFAULTS
GC_DEFAULTS
PG_DUMP_MAGIC
PG_DUMP_MULTI_VALUE_ARGS

rubocop:disable Style/SymbolArray

Public Class Methods

backup(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 105
def self.backup(opts)
  backup_pg_compress(opts)
end
backup_pg_compress(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 158
def self.backup_pg_compress(opts)
  opts = opts.dup

  # discard dbname as pg_basebackup does not connect to a specific database
  opts.delete(:dbname)

  path = Pathname.new(opts.delete(:local_file))
  FileUtils.mkdir_p(path.dirname)

  # Build commandline from AwesomeSpawn
  args = {:z => nil, :format => "t", :wal_method => "fetch", :pgdata => "-"}
  cmd  = AwesomeSpawn.build_command_line("pg_basebackup", combine_command_args(opts, args))
  logger.info("MIQ(#{name}.#{__method__}) Running command... #{cmd}")

  # Run command in a separate thread
  read, write    = IO.pipe
  error_path     = Dir::Tmpname.create("") { |tmpname| tmpname }
  process_thread = Process.detach(Kernel.spawn(pg_env(opts), cmd, :out => write, :err => error_path))
  stream_reader  = Thread.new { IO.copy_stream(read, path) } # Copy output to path
  write.close

  # Wait for them to finish
  process_status = process_thread.value
  stream_reader.join
  read.close

  handle_error(cmd, process_status.exitstatus, error_path)
  path.to_s
end
backup_pg_dump(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 146
def self.backup_pg_dump(opts)
  opts = opts.dup
  dbname = opts.delete(:dbname)

  args = combine_command_args(opts, :format => "c", :file => opts[:local_file], nil => dbname)
  args = handle_multi_value_pg_dump_args!(opts, args)

  FileUtils.mkdir_p(File.dirname(opts.fetch(:local_file, "")))
  run_command_with_logging("pg_dump", opts, args)
  opts[:local_file]
end
base_backup_file?(file) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 101
def self.base_backup_file?(file)
  File.open(file, "rb") { |f| f.readpartial(2) } == BASE_BACKUP_MAGIC
end
data_directory() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 9
def self.data_directory
  Pathname.new(ENV.fetch("APPLIANCE_PG_DATA"))
end
database_disk_filesystem() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 46
def self.database_disk_filesystem
  "xfs".freeze
end
database_size(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 83
def self.database_size(opts)
  result = run_command("psql", opts, :command => "SELECT pg_database_size('#{opts[:dbname]}');")
  result.match(/^\s+([0-9]+)\n/)[1].to_i
end
gc(options = {}) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 237
def self.gc(options = {})
  options = (options[:aggressive] ? GC_AGGRESSIVE_DEFAULTS : GC_DEFAULTS).merge(options)

  result = vacuum(options)
  logger.info("MIQ(#{name}.#{__method__}) Output... #{result}") if result.to_s.length > 0

  if options[:reindex]
    result = reindex(options)
    logger.info("MIQ(#{name}.#{__method__}) Output... #{result}") if result.to_s.length > 0
  end
end
group() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 34
def self.group
  user
end
initialized?() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 57
def self.initialized?
  !Dir[data_directory.join("*")].empty?
end
local_server_in_recovery?() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 65
def self.local_server_in_recovery?
  data_directory.join("recovery.conf").exist?
end
local_server_status() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 69
def self.local_server_status
  if service_running?
    "running (#{local_server_in_recovery? ? "standby" : "primary"})"
  elsif initialized?
    "initialized and stopped"
  else
    "not initialized"
  end
end
logical_volume_name() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 38
def self.logical_volume_name
  "lv_pg".freeze
end
logical_volume_path() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 79
def self.logical_volume_path
  Pathname.new("/dev").join(volume_group_name, logical_volume_name)
end
mount_point() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 13
def self.mount_point
  Pathname.new(ENV.fetch("APPLIANCE_PG_MOUNT_POINT"))
end
package_name() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 25
def self.package_name
  ENV.fetch('APPLIANCE_PG_PACKAGE_NAME')
end
pg_dump_file?(file) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 96
def self.pg_dump_file?(file)
  File.open(file, "rb") { |f| f.readpartial(5) } == PG_DUMP_MAGIC
end
prep_data_directory() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 88
def self.prep_data_directory
  # initdb will fail if the database directory is not empty or not owned by the PostgresAdmin.user
  FileUtils.mkdir(PostgresAdmin.data_directory) unless Dir.exist?(PostgresAdmin.data_directory)
  FileUtils.chown_R(PostgresAdmin.user, PostgresAdmin.group, PostgresAdmin.data_directory)
  FileUtils.rm_rf(PostgresAdmin.data_directory.children.map(&:to_s))
end
recreate_db(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 188
def self.recreate_db(opts)
  dbname = opts[:dbname]
  opts = opts.merge(:dbname => 'postgres')
  run_command("psql", opts, :command => "DROP DATABASE IF EXISTS #{dbname}")
  run_command("psql", opts, :command => "CREATE DATABASE #{dbname} WITH OWNER = #{opts[:username] || 'root'} ENCODING = 'UTF8'")
end
reindex(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 261
def self.reindex(opts)
  args = {}
  args[:table] = opts[:table] if opts[:table]
  run_command("reindexdb", opts, args)
end
restore(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 109
def self.restore(opts)
  file        = opts[:local_file]
  backup_type = opts.delete(:backup_type) || validate_backup_file_type(file)

  prepare_restore(backup_type, opts[:dbname])

  case backup_type
  when :pgdump     then restore_pg_dump(opts)
  when :basebackup then restore_pg_basebackup(file)
  else
    raise "#{file} is not a database backup"
  end
end
restore_pg_basebackup(file) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 123
def self.restore_pg_basebackup(file)
  pg_service = LinuxAdmin::Service.new(service_name)

  pg_service.stop
  prep_data_directory

  require 'rubygems/package'

  # Using a Gem::Package instance for the #extract_tar_gz method, so we don't
  # have to re-write all of that logic.  Mostly making use of
  # `Gem::Package::TarReader` + `Zlib::GzipReader` that is already part of
  # rubygems/stdlib and integrated there.
  unpacker = Gem::Package.new("obviously_not_a_gem")
  File.open(file, IO::RDONLY | IO::NONBLOCK) do |backup_file|
    unpacker.extract_tar_gz(backup_file, data_directory.to_s)
  end

  FileUtils.chown_R(PostgresAdmin.user, PostgresAdmin.group, PostgresAdmin.data_directory)

  pg_service.start
  file
end
restore_pg_dump(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 195
def self.restore_pg_dump(opts)
  recreate_db(opts)
  args = { :verbose => nil, :exit_on_error => nil }

  if File.pipe?(opts[:local_file])
    cmd_args   = combine_command_args(opts, args)
    cmd        = AwesomeSpawn.build_command_line("pg_restore", cmd_args)
    error_path = Dir::Tmpname.create("") { |tmpname| tmpname }
    spawn_args = { :err => error_path, :in => [opts[:local_file].to_s, "rb"] }

    logger.info("MIQ(#{name}.#{__method__}) Running command... #{cmd}")
    process_thread = Process.detach(Kernel.spawn(pg_env(opts), cmd, spawn_args))
    process_status = process_thread.value

    handle_error(cmd, process_status.exitstatus, error_path)
  else
    args[nil] = opts[:local_file]
    run_command("pg_restore", opts, args)
  end
  opts[:local_file]
end
run_command(cmd_str, opts, args) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 267
def self.run_command(cmd_str, opts, args)
  run_command_with_logging(cmd_str, opts, combine_command_args(opts, args))
end
run_command_with_logging(cmd_str, opts, params = {}) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 271
def self.run_command_with_logging(cmd_str, opts, params = {})
  logger.info("MIQ(#{name}.#{__method__}) Running command... #{AwesomeSpawn.build_command_line(cmd_str, params)}")
  AwesomeSpawn.run!(cmd_str, :params => params, :env => pg_env(opts)).output
end
Also aliased as: runcmd_with_logging
runcmd_with_logging(cmd_str, opts, params = {})

Temporary alias due to manageiq core stubbing this method

service_name() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 21
def self.service_name
  ENV.fetch("APPLIANCE_PG_SERVICE")
end
service_running?() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 61
def self.service_running?
  LinuxAdmin::Service.new(service_name).running?
end
template_directory() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 17
def self.template_directory
  Pathname.new(ENV.fetch("APPLIANCE_TEMPLATE_DIRECTORY"))
end
user() click to toggle source

Unprivileged user to run postgresql

# File lib/manageiq/appliance_console/postgres_admin.rb, line 30
def self.user
  "postgres".freeze
end
vacuum(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 249
def self.vacuum(opts)
  # TODO: Add a real exception here
  raise "Vacuum requires database" unless opts[:dbname]

  args = {}
  args[:analyze] = nil if opts[:analyze]
  args[:full]    = nil if opts[:full]
  args[:verbose] = nil if opts[:verbose]
  args[:table]   = opts[:table] if opts[:table]
  run_command("vacuumdb", opts, args)
end
volume_group_name() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 42
def self.volume_group_name
  "vg_data".freeze
end
with_pg_connection(db_opts = {:user => user, :dbname => user}) { |conn| ... } click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 50
def self.with_pg_connection(db_opts = {:user => user, :dbname => user})
  conn = PG.connect(db_opts)
  yield conn
ensure
  conn.close if conn
end

Private Class Methods

application_connections?() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 350
                     def self.application_connections?
  result = [{"count" => 0}]

  with_pg_connection do |conn|
    result = conn.exec("SELECT COUNT(pid) FROM pg_stat_activity WHERE application_name LIKE '%MIQ%'")
  end

  result[0]["count"].to_i > 0
end
combine_command_args(opts, args) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 281
                     def self.combine_command_args(opts, args)
  default_args            = {:no_password => nil}
  default_args[:dbname]   = opts[:dbname]   if opts[:dbname]
  default_args[:username] = opts[:username] if opts[:username]
  default_args[:host]     = opts[:hostname] if opts[:hostname]
  default_args[:port]     = opts[:port]     if opts[:port]
  default_args.merge(args)
end
connection_count(backup_type, dbname) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 386
                     def self.connection_count(backup_type, dbname)
  result = nil

  with_pg_connection do |conn|
    query  = "SELECT COUNT(pid) FROM pg_stat_activity"
    query << " WHERE backend_type = 'client backend'" if backup_type == :basebackup
    query << " WHERE datname = '#{dbname}'"           if backup_type == :pgdump
    result = conn.exec(query)
  end

  result[0]["count"].to_i
end
disable_replication(dbname) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 360
                     def self.disable_replication(dbname)
  require 'pg/logical_replication'

  with_pg_connection do |conn|
    pglogical = PG::LogicalReplication::Client.new(conn)

    if pglogical.subscriber?
      pglogical.subcriptions(dbname).each do |subscriber|
        sub_id = subscriber["subscription_name"]
        begin
          pglogical.drop_subscription(sub_id, true)
        rescue PG::InternalError => e
          raise unless e.message.include?("could not connect to publisher")
          raise unless e.message.match?(/replication slot .* does not exist/)

          pglogical.disable_subscription(sub_id).check
          pglogical.alter_subscription_options(sub_id, "slot_name" => "NONE")
          pglogical.drop_subscription(sub_id, true)
        end
      end
    elsif pglogical.publishes?('miq')
      pglogical.drop_publication('miq')
    end
  end
end
handle_error(cmd, exit_status, error_path) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 321
                     def self.handle_error(cmd, exit_status, error_path)
  if exit_status != 0
    result = AwesomeSpawn::CommandResult.new(cmd, "", File.read(error_path), exit_status)
    message = AwesomeSpawn::CommandResultError.default_message(cmd, exit_status)
    logger.error("AwesomeSpawn: #{message}")
    logger.error("AwesomeSpawn: #{result.error}")
    raise AwesomeSpawn::CommandResultError.new(message, result)
  end
ensure
  File.delete(error_path) if File.exist?(error_path)
end
handle_multi_value_pg_dump_args!(opts, args) click to toggle source

rubocop:enable Style/SymbolArray

NOTE: Potentially mutates opts hash (args becomes new array and not mutated by this method)

# File lib/manageiq/appliance_console/postgres_admin.rb, line 309
                     def self.handle_multi_value_pg_dump_args!(opts, args)
  if opts.keys.any? { |key| PG_DUMP_MULTI_VALUE_ARGS.include?(key) }
    args = args.to_a
    PG_DUMP_MULTI_VALUE_ARGS.each do |table_key|
      next unless opts.key?(table_key)
      table_val = opts.delete(table_key)
      args += Array.wrap(table_val).map! { |v| [table_key, v] }
    end
  end
  args
end
logger() click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 290
                     def self.logger
  ManageIQ::ApplianceConsole.logger
end
pg_env(opts) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 294
                     def self.pg_env(opts)
  {
    "PGUSER"     => opts[:username],
    "PGPASSWORD" => opts[:password]
  }.delete_blanks
end
prepare_restore(backup_type, dbname) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 333
                     def self.prepare_restore(backup_type, dbname)
  if application_connections?
    message = "Database restore failed. Shut down all evmserverd processes before attempting a database restore"
    ManageIQ::ApplianceConsole.logger.error(message)
    raise message
  end

  disable_replication(dbname)

  conn_count = connection_count(backup_type, dbname)
  if conn_count > 1
    message = "Database restore failed. #{conn_count - 1} connections remain to the database."
    ManageIQ::ApplianceConsole.logger.error(message)
    raise message
  end
end
validate_backup_file_type(file) click to toggle source
# File lib/manageiq/appliance_console/postgres_admin.rb, line 399
                     def self.validate_backup_file_type(file)
  if base_backup_file?(file)
    :basebackup
  elsif pg_dump_file?(file)
    :pgdump
  else
    message = "#{filename} is not in a recognized database backup format"
    ManageIQ::ApplianceConsole.error(message)
    raise message
  end
end