action = None # The action to do

args = [] # The list of parameters received in console

logger = None # A logger to show and log some messages

def __init__(self, action, args):

self.action = action

self.args = args

self.logger = self.get_logger()

try:

# Create mailer if necessary

if self.args.config_mailer:

self.create_mailer()

except Exception:

pass

# Stop execution if the user running the program is root

Dir.forbid_root(self.logger)

@staticmethod

def show_dbs(dbs_list, logger):

'''

Target:

- show in console and log a list of databases.

Parameters:

- dbs_list: the list of databases to be shown.

- logger: a logger to show and log some messages.

'''

logger.highlight('info', Messenger.ANALIZING_PG_DATA, 'white')

for db in dbs_list: # Para cada BD en PostgreSQL...

message = Messenger.DETECTED_DB.format(dbname=db['datname'])

logger.info(message)

@staticmethod

def get_cfg_vars(config_type, config_path, logger=None):

'''

Target:

- get all the variables stored in a config file with cfg extension.

Parameters:

- config_type: the type of config file which is going to be loaded,

to differ it from the other types which will have different

sections and variables.

- logger: a logger to show and log some messages.

Return:

- the parser which will contain all the config file variables.

'''

configurator = Configurator()

# In the case of logger being None, this is because a logger config

# file is being loaded to specify some settings

if logger:

configurator.load_cfg(config_type, config_path, logger)

else:

configurator.load_cfg(config_type, config_path)

return configurator.parser

def get_logger(self):

'''

Target:

- get a logger object with its variables.

Return:

- a logger to show and log some messages.

'''

# If the user specified a logger config file through console...

if self.args.config_logger:

config_type = 'log'

# Get the variables from the config file, without sending any

# logger!! It would give a redundancy error

parser = Orchestrator.get_cfg_vars(config_type,

self.args.config_logger)

# Overwrite the config variables with the console ones if necessary

if self.args.logger_logfile:

parser.log_vars['log_dir'] = self.args.logger_logfile

if self.args.logger_level:

parser.log_vars['level'] = self.args.logger_level

if self.args.logger_mute:

parser.log_vars['mute'] = self.args.logger_mute

# Create the logger with the specified variables

logger = Logger(parser.log_vars['log_dir'],

parser.log_vars['level'], parser.log_vars['mute'])

# If the user did not specify a logger config file through console...

else:

# Create the logger with the console variables

logger = Logger(self.args.logger_logfile, self.args.logger_level,

self.args.logger_mute)

return logger

def create_mailer(self):

'''

Target:

- get a mailer object with variables to send emails informing

about the results of the program's execution.

Return:

- a mailer which will send emails informing about the results of

the program's execution.

'''

config_type = 'mail'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type,

self.args.config_mailer,

self.logger)

# Create the mailer with the specified variables

self.logger.create_mailer(parser.mail_vars['level'],

parser.mail_vars['name'],

parser.mail_vars['address'],

parser.mail_vars['password'],

parser.mail_vars['to'],

parser.mail_vars['cc'],

parser.mail_vars['bcc'],

parser.mail_vars['server_tag'],

parser.mail_vars['external_ip'],

self.action)

def get_connecter(self):

'''

Target:

- get a connecter object with its variables.

Return:

- a connecter which will allow queries to PostgreSQL.

'''

# If the user specified a connecter config file through console...

if self.args.config_connection:

config_type = 'connect'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type,

self.args.config_connection,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.pg_host:

parser.conn_vars['server'] = self.args.pg_host

if self.args.pg_user:

parser.conn_vars['user'] = self.args.pg_user

if self.args.pg_port:

parser.conn_vars['port'] = self.args.pg_port

# Create the connecter with the specified variables

connecter = Connecter(server=parser.conn_vars['server'],

user=parser.conn_vars['user'],

port=parser.conn_vars['port'],

logger=self.logger)

# If the user did not specify a connecter config file through console..

else:

# Create the connecter with the console variables

connecter = Connecter(server=self.args.pg_host,

user=self.args.pg_user,

port=self.args.pg_port, logger=self.logger)

return connecter

def get_alterer(self, connecter):

'''

Target:

- get an alterer object with variables to change owners of some

PostgreSQL databases.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- an alterer which will change owners of PostgreSQL databases.

'''

# If the user specified an alterer config file through console...

if self.args.config:

config_type = 'alter'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_name:

parser.bkp_vars['in_dbs'] = True

elif self.args.old_role:

parser.bkp_vars['old_role'] = self.args.old_role

elif self.args.new_role:

parser.bkp_vars['new_role'] = self.args.new_role

else:

pass

# Create the alterer with the specified variables

alterer = Alterer(connecter, parser.bkp_vars['in_dbs'],

parser.bkp_vars['old_role'],

parser.bkp_vars['new_role'], self.logger)

# If the user did not specify an alterer config file through console...

else:

# Create the alterer with the console variables

alterer = Alterer(connecter, self.args.db_name, self.args.old_role,

self.args.new_role, self.logger)

return alterer

def get_db_backer(self, connecter):

'''

Target:

- get a backer object with variables to backup databases.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a backer which will backup databases.

'''

# If the user specified a backer config file through console...

if self.args.config:

config_type = 'backup'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if

# necessary

if self.args.bkp_path:

parser.bkp_vars['bkp_path'] = self.args.bkp_path

if self.args.group:

parser.bkp_vars['group'] = self.args.group

if self.args.backup_format:

parser.bkp_vars['bkp_type'] = self.args.backup_format

if self.args.db_name:

parser.bkp_vars['in_dbs'] = self.args.db_name

parser.bkp_vars['ex_dbs'] = []

parser.bkp_vars['in_regex'] = ''

parser.bkp_vars['ex_regex'] = ''

if self.args.ex_templates:

parser.bkp_vars['ex_templates'] = True

elif self.args.no_ex_templates:

parser.bkp_vars['ex_templates'] = False

if self.args.vacuum:

parser.bkp_vars['vacuum'] = True

elif self.args.no_vacuum:

parser.bkp_vars['vacuum'] = False

if self.args.db_owner:

parser.bkp_vars['db_owner'] = self.args.db_owner

# Create the backer with the specified variables

backer = Backer(connecter, parser.bkp_vars['bkp_path'],

parser.bkp_vars['group'],

parser.bkp_vars['bkp_type'],

parser.bkp_vars['prefix'],

parser.bkp_vars['in_dbs'],

parser.bkp_vars['in_regex'],

parser.bkp_vars['in_priority'],

parser.bkp_vars['ex_dbs'],

parser.bkp_vars['ex_regex'],

parser.bkp_vars['ex_templates'],

parser.bkp_vars['vacuum'],

parser.bkp_vars['db_owner'], self.logger)

# If the user did not specify a backer config file through console...

else:

if self.args.ex_templates:

ex_templates = True

elif self.args.no_ex_templates:

ex_templates = False

else:

ex_templates = True

if self.args.vacuum:

vacuum = True

elif self.args.no_vacuum:

vacuum = False

else:

vacuum = True

# Create the backer with the console variables

backer = Backer(connecter, bkp_path=self.args.bkp_path,

group=self.args.group,

bkp_type=self.args.backup_format,

in_dbs=self.args.db_name,

ex_templates=ex_templates, vacuum=vacuum,

db_owner=self.args.db_owner,

logger=self.logger)

return backer

def get_cl_backer(self, connecter):

'''

Target:

- get a backer object with variables to backup databases' clusters.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a backer which will backup databases' clusters.

'''

# If the user specified a backer config file through console...

if self.args.config:

config_type = 'backup_all'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.bkp_path:

parser.bkp_vars['bkp_path'] = self.args.bkp_path

if self.args.group:

parser.bkp_vars['group'] = self.args.group

if self.args.backup_format:

parser.bkp_vars['bkp_type'] = self.args.backup_format

if self.args.vacuum:

parser.bkp_vars['vacuum'] = True

elif self.args.no_vacuum:

parser.bkp_vars['vacuum'] = False

# Create the backer with the specified variables

backer = BackerCluster(connecter, parser.bkp_vars['bkp_path'],

parser.bkp_vars['group'],

parser.bkp_vars['bkp_type'],

parser.bkp_vars['prefix'],

parser.bkp_vars['vacuum'], self.logger)

# If the user did not specify a backer config file through console...

else:

if self.args.vacuum:

vacuum = True

elif self.args.no_vacuum:

vacuum = False

else:

vacuum = True

# Create the backer with the console variables

backer = BackerCluster(connecter, bkp_path=self.args.bkp_path,

group=self.args.group,

bkp_type=self.args.backup_format,

vacuum=vacuum, logger=self.logger)

return backer

def get_dropper(self, connecter):

'''

Target:

- get a dropper object with variables to drop some PostgreSQL

databases.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a dropper which will delete some PostgreSQL databases.

'''

# If the user specified a dropper config file through console...

if self.args.config:

config_type = 'drop'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_name:

parser.bkp_vars['in_dbs'] = self.args.db_name

# Create the dropper with the specified variables

dropper = Dropper(connecter, parser.bkp_vars['in_dbs'],

self.logger)

# If the user did not specify a dropper config file through console...

else:

# Create the dropper with the console variables

dropper = Dropper(connecter, self.args.db_name, self.logger)

return dropper

def get_informer(self, connecter):

'''

Target:

- get an informer object with variables to show some PostgreSQL

information.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a informer which will get and show some PostgreSQL information.

'''

# Create the informer with the console variables

informer = Informer(connecter, self.args.details_conns,

self.args.details_dbs, self.args.details_users,

self.logger)

return informer

def get_replicator(self, connecter):

'''

Target:

- get a replicator object with variables to clone a PostgreSQL

database.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a replicator which will clone a PostgreSQL database.

'''

# If the user specified a replicator config file through console...

if self.args.config:

config_type = 'replicate'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_name:

parser.bkp_vars['new_dbname'] = self.args.db_name[0]

parser.bkp_vars['original_dbname'] = self.args.db_name[1]

# Create the replicator with the specified variables

replicator = Replicator(connecter, parser.bkp_vars['new_dbname'],

parser.bkp_vars['original_dbname'],

self.logger)

# If the user did not specify a replicator config file through

# console...

else:

# Create the replicator with the console variables

replicator = Replicator(connecter, self.args.db_name[0],

self.args.db_name[1], self.logger)

return replicator

def get_db_restorer(self, connecter):

'''

Target:

- get a restorer object with variables to restore a database backup

in PostgreSQL.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a restorer which will restore a PostgreSQL database.

'''

# If the user specified a restorer config file through console...

if self.args.config:

config_type = 'restore'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_backup:

parser.bkp_vars['bkp_path'] = self.args.db_backup[0]

parser.bkp_vars['new_dbname'] = self.args.db_backup[1]

# Create the restorer with the specified variables

restorer = Restorer(connecter, parser.bkp_vars['bkp_path'],

parser.bkp_vars['new_dbname'], self.logger)

# If the user did not specify a restorer config file through console...

else:

# Create the restorer with the console variables

restorer = Restorer(connecter, self.args.db_backup[0],

self.args.db_backup[1], self.logger)

return restorer

def get_cl_restorer(self, connecter):

'''

Target:

- get a restorer object with variables to restore a cluster backup

in PostgreSQL.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a restorer which will restore a PostgreSQL cluster.

'''

# If the user specified a restorer config file through console...

if self.args.config:

config_type = 'restore_all'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.cluster_backup:

parser.bkp_vars['bkp_path'] = self.args.cluster_backup

# Create the restorer with the specified variables

restorer = RestorerCluster(connecter, parser.bkp_vars['bkp_path'],

self.logger)

# If the user did not specify a restorer config file through console...

else:

# Create the restorer with the console variables

restorer = Restorer(connecter, self.args.cluster_backup,

self.logger)

return restorer

def get_scheduler(self):

'''

Target:

- get a scheduler object with variables to modify or show the

content of the program's CRON file.

Return:

- a scheduler which will modify or show the content of the

program's CRON file.

'''

# If the user specified a scheduler config file through console...

if self.args.add_config:

config_type = 'schedule'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type,

self.args.add_config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.add:

parser.bkp_vars['time'] = self.args.add[0]

parser.bkp_vars['command'] = self.args.add[1]

# Create the scheduler with the specified variables

scheduler = Scheduler(parser.bkp_vars['time'],

parser.bkp_vars['command'], self.logger)

elif self.args.remove_config:

config_type = 'schedule'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type,

self.args.remove_config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.remove:

parser.bkp_vars['time'] = self.args.remove[0]

parser.bkp_vars['command'] = self.args.remove[1]

# Create the scheduler with the specified variables

scheduler = Scheduler(parser.bkp_vars['time'],

parser.bkp_vars['command'], self.logger)

# If the user did not specify a scheduler config file through console..

elif self.args.add:

scheduler = Scheduler(self.args.add[0], self.args.add[1],

self.logger)

elif self.args.remove:

scheduler = Scheduler(self.args.remove[0], self.args.remove[1],

self.logger)

else:

scheduler = Scheduler(logger=self.logger)

return scheduler

def get_terminator(self, connecter):

'''

Target:

- get a terminator object with variables to terminate connections

to PostgreSQL.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a terminator which will terminate connections to

PostgreSQL.

'''

# If the user specified a terminator config file through console...

if self.args.config:

config_type = 'terminate'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.all:

parser.kill_vars['kill_all'] = True

elif self.args.user:

parser.kill_vars['kill_user'] = self.args.db_name

elif self.args.db_name:

parser.kill_vars['kill_dbs'] = self.args.user

else:

pass

# Create the terminator with the specified variables

terminator = Terminator(connecter,

parser.kill_vars['kill_all'],

parser.kill_vars['kill_user'],

parser.kill_vars['kill_dbs'],

self.logger)

# If the user did not specify a terminator config file through

# console...

else:

# Create the terminator with the console variables

terminator = Terminator(connecter, self.args.all,

self.args.user, self.args.db_name,

self.logger)

return terminator

def get_db_trimmer(self):

'''

Target:

- get a trimmer object with its variables to delete some databases'

backups in a selected directory.

Return:

- a trimmer which will delete databases' backups.

'''

# If the user specified a trimmer config file through console...

if self.args.config:

config_type = 'trim'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_name:

parser.bkp_vars['in_dbs'] = self.args.db_name

parser.bkp_vars['ex_dbs'] = []

parser.bkp_vars['in_regex'] = ''

parser.bkp_vars['ex_regex'] = ''

if self.args.bkp_folder:

parser.bkp_vars['bkp_path'] = self.args.bkp_folder

if self.args.prefix:

parser.bkp_vars['prefix'] = self.args.prefix

if self.args.n_backups:

parser.bkp_vars['min_n_bkps'] = self.args.n_backups

if self.args.expiry_days:

parser.bkp_vars['exp_days'] = self.args.expiry_days

if self.args.max_size:

parser.bkp_vars['max_size'] = self.args.max_size

if parser.bkp_vars['pg_warnings']:

connecter = self.get_connecter()

else:

connecter = None

# Create the trimmer with the specified variables

trimmer = Trimmer(parser.bkp_vars['bkp_path'],

parser.bkp_vars['prefix'],

parser.bkp_vars['in_dbs'],

parser.bkp_vars['in_regex'],

parser.bkp_vars['in_priority'],

parser.bkp_vars['ex_dbs'],

parser.bkp_vars['ex_regex'],

parser.bkp_vars['min_n_bkps'],

parser.bkp_vars['exp_days'],

parser.bkp_vars['max_size'],

parser.bkp_vars['pg_warnings'], connecter,

self.logger)

# If the user did not specify a trimmer config file through console...

else:

# There is no option "pg_warnings" in console so it is obligatory

# to connect to PostgreSQL here

connecter = self.get_connecter()

# Create the trimmer with the console variables

trimmer = Trimmer(connecter=connecter,

bkp_path=self.args.bkp_folder,

prefix=self.args.prefix,

in_dbs=self.args.db_name,

min_n_bkps=self.args.n_backups,

exp_days=self.args.expiry_days,

max_size=self.args.max_size, logger=self.logger)

return trimmer

def get_cl_trimmer(self):

'''

Target:

- get a trimmer object with its variables to delete some clusters'

backups in a selected directory.

Return:

- a trimmer which will delete clusters' backups.

'''

# If the user specified a trimmer config file through console...

if self.args.config:

config_type = 'trim_all'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.bkp_folder:

parser.bkp_vars['bkp_path'] = self.args.bkp_folder

if self.args.prefix:

parser.bkp_vars['prefix'] = self.args.prefix

if self.args.n_backups:

parser.bkp_vars['min_n_bkps'] = self.args.n_backups

if self.args.expiry_days:

parser.bkp_vars['exp_days'] = self.args.expiry_days

if self.args.max_size:

parser.bkp_vars['max_size'] = self.args.max_size

# Create the trimmer with the specified variables

trimmer = TrimmerCluster(parser.bkp_vars['bkp_path'],

parser.bkp_vars['prefix'],

parser.bkp_vars['min_n_bkps'],

parser.bkp_vars['exp_days'],

parser.bkp_vars['max_size'], self.logger)

else:

# Create the trimmer with the console variables

trimmer = TrimmerCluster(self.args.bkp_folder, self.args.prefix,

self.args.n_backups,

self.args.expiry_days, self.args.max_size,

self.logger)

return trimmer

def get_vacuumer(self, connecter):

'''

Target:

- get a vacuumer object with variables to vacuum databases in

PostgreSQL.

Parameters:

- connecter: an object with connection parameters to connect to

PostgreSQL.

Return:

- a vacuumer which will vacuum PostgreSQL databases.

'''

# If the user specified a vacuumer config file through console...

if self.args.config:

config_type = 'vacuum'

# Get the variables from the config file

parser = Orchestrator.get_cfg_vars(config_type, self.args.config,

self.logger)

# Overwrite the config variables with the console ones if necessary

if self.args.db_name:

parser.bkp_vars['in_dbs'] = self.args.db_name

parser.bkp_vars['ex_dbs'] = []

parser.bkp_vars['in_regex'] = ''

parser.bkp_vars['ex_regex'] = ''

if self.args.db_owner:

parser.bkp_vars['db_owner'] = self.args.db_owner

# Create the vacuumer with the specified variables

vacuumer = Vacuumer(connecter,

parser.bkp_vars['in_dbs'],

parser.bkp_vars['in_regex'],

parser.bkp_vars['in_priority'],

parser.bkp_vars['ex_dbs'],

parser.bkp_vars['ex_regex'],

parser.bkp_vars['ex_templates'],

parser.bkp_vars['db_owner'],

self.logger)

# If the user did not specify a vacuumer config file through console...

else:

# Create the vacuumer with the console variables

vacuumer = Vacuumer(connecter, in_dbs=self.args.db_name,

db_owner=self.args.db_owner,

logger=self.logger)

return vacuumer

def setup_alterer(self):

'''

Target:

- change the owner of the specified databases in PostgreSQL.

'''

connecter = self.get_connecter()

self.logger.debug(Messenger.BEGINNING_EXE_ALTERER)

alterer = self.get_alterer(connecter)

# Check if the role of user connected to PostgreSQL is superuser

pg_superuser = connecter.is_pg_superuser()

if not pg_superuser:

# Users who are not superusers will only be able to backup the

# databases they own

owner = connecter.user

self.logger.highlight('warning', Messenger.ACTION_DB_NO_SUPERUSER,

'yellow', effect='bold')

else:

owner = ''

# Get PostgreSQL databases' names, connection permissions and owners

dbs_all = connecter.get_pg_dbs_data(ex_templates=False, db_owner=owner)

# Show and log their names

Orchestrator.show_dbs(dbs_all, self.logger)

# Get the target databases in a list

alt_list = DbSelector.get_filtered_dbs(

dbs_all=dbs_all, in_dbs=alterer.in_dbs, logger=self.logger)

# Terminate every connection to the target databases if necessary

if self.args.terminate:

terminator = Terminator(connecter, target_dbs=alt_list,

logger=self.logger)

terminator.terminate_backend_dbs(alt_list)

# Delete the databases

alterer.alter_dbs_owner(alt_list)

# Close connection to PostgreSQL

connecter.pg_disconnect()

def setup_backer(self):

'''

Target:

- executes the backer depending on the type of backup to make, the

role of the user who is connected to PostgreSQL and the rest of

the conditions. It calls a terminator if necessary.

'''

connecter = self.get_connecter()

# Get databases or clusters' backer depending on the option selected

# by the user in console

if self.args.cluster:

self.logger.debug(Messenger.BEGINNING_EXE_CL_BACKER)

backer = self.get_cl_backer(connecter)

else:

self.logger.debug(Messenger.BEGINNING_EXE_DB_BACKER)

backer = self.get_db_backer(connecter)

# If necessary, add group and bkp_path to the mailer to be sent within

# the process information

if self.args.config_mailer:

self.logger.mailer.add_group(backer.group)

path = backer.bkp_path + backer.group

self.logger.mailer.add_bkp_path(path)

# Check if the role of user connected to PostgreSQL is superuser

pg_superuser = connecter.is_pg_superuser()

if not pg_superuser:

if self.args.cluster is False:

# Users who are not superusers will only be able to backup the

# databases they own

backer.db_owner = connecter.user

self.logger.highlight(

'warning', Messenger.ACTION_DB_NO_SUPERUSER,

'yellow', effect='bold')

else: # Backup the cluster can only be made by superuser

self.logger.stop_exe(Messenger.ACTION_CL_NO_SUPERUSER)

# Make the backups

if self.args.cluster is False: # Backup databases

# Get PostgreSQL databases' names, connection permissions and

# owners

dbs_all = connecter.get_pg_dbs_data(backer.ex_templates,

backer.db_owner)

# Show and log their names

Orchestrator.show_dbs(dbs_all, self.logger)

# Get the target databases in a list

bkp_list = DbSelector.get_filtered_dbs(

dbs_all, backer.in_dbs, backer.ex_dbs, backer.in_regex,

backer.ex_regex, backer.in_priority, self.logger)

# Terminate every connection to these target databases if necessary

if self.args.terminate:

terminator = Terminator(connecter, target_dbs=bkp_list,

logger=self.logger)

terminator.terminate_backend_dbs(bkp_list)

backer.backup_dbs(bkp_list) # Make databases' backup

else: # Backup a cluster

# Terminate every connection to any database of the cluster if

# necessary

if self.args.terminate:

terminator = Terminator(connecter, target_all=True,

logger=self.logger)

terminator.terminate_backend_all()

backer.backup_cl() # Make cluster's backup

# Close connection to PostgreSQL

connecter.pg_disconnect()

def setup_dropper(self):

'''

Target:

- delete specified databases in PostgreSQL.

'''

connecter = self.get_connecter()

self.logger.debug(Messenger.BEGINNING_EXE_DROPPER)

dropper = self.get_dropper(connecter)

# Terminate every connection to the target databases if necessary

if self.args.terminate:

terminator = Terminator(connecter, target_dbs=dropper.dbnames,

logger=self.logger)

terminator.terminate_backend_dbs(dropper.dbnames)

# Delete the databases

dropper.drop_pg_dbs(dropper.dbnames)

# Close connection to PostgreSQL

connecter.pg_disconnect()

def setup_informer(self):

'''

Target:

- give information about PostgreSQL to the user.

'''

connecter = self.get_connecter()

self.logger.debug(Messenger.BEGINNING_EXE_INFORMER)

informer = self.get_informer(connecter)

if self.args.details_conns is not None:

informer.show_pg_conns_data()

if self.args.list_conns:

informer.show_pg_connpids()

if self.args.details_dbs is not None:

informer.show_pg_dbs_data()

if self.args.list_dbs:

informer.show_pg_dbnames()

if self.args.details_users is not None:

informer.show_pg_users_data()

if self.args.list_users:

informer.show_pg_usernames()

if self.args.version_pg:

informer.show_pg_version()

if self.args.version_num_pg:

informer.show_pg_nversion()

if self.args.time_start:

informer.show_pg_time_start()

if self.args.time_up:

informer.show_pg_time_up()

# Close connection to PostgreSQL

connecter.pg_disconnect()

def setup_replicator(self):

'''

Target:

- clone a database in PostgreSQL.

'''

connecter = self.get_connecter()

self.logger.debug(Messenger.BEGINNING_EXE_REPLICATOR)

replicator = self.get_replicator(connecter)

pg_superuser = connecter.is_pg_superuser()

if not pg_superuser:

connecter.cursor.execute(Queries.GET_PG_DB_SOME_DATA,

(replicator.original_dbname, ))

db = connecter.cursor.fetchone()

if db['owner'] != connecter.user:

self.logger.stop_exe(Messenger.ACTION_DB_NO_SUPERUSER)

# Terminate every connection to the database which is going to be

# replicated, if necessary

if self.args.terminate:

terminator = Terminator(connecter,

target_dbs=[replicator.original_dbname],

logger=self.logger)

terminator.terminate_backend_dbs([replicator.original_dbname])

# Clone the database

replicator.replicate_pg_db()

# Close connection to PostgreSQL

connecter.pg_disconnect()

def setup_restorer(self):

'''

Target:

- restore a specified backup file as a new database or cluster in

PostgreSQL.

'''

connecter = self.get_connecter()

if self.args.cluster: # Restore a cluster (must be created first)

# Check if the role of user connected to PostgreSQL is

# superuser

pg_superuser = connecter.is_pg_superuser()

if pg_superuser:

restorer = self.get_cl_restorer(connecter)

self.logger.debug(Messenger.BEGINNING_EXE_CL_RESTORER)

restorer.restore_cluster_backup()

else: