def remove(self):
try: return self.REMOVE
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
# raise ValueError(err)
return False
def main(self):
""""""
if self.directory: log.info("directory = '{D}'".format(D = self.DIRECTORY))
if self.director_path: log.info("director_path = '{D}'".format(D = self.DIRECTORPATH))
if self.remove: log.info("remove = '{D}'".format(D = self.REMOVE))
if self.generate: log.info("generate = '{D}'".format(D = self.GENERATE))
log.info("test = '{D}'".format(D = self.test))
if self.generate:
self.dir_list = self.get_dir_list()
self.gen_jobdefs()
self.gen_filesets()
self.gen_jobs()
elif self.remove:
self.rem_jobdefs()
self.rem_filesets()
self.rem_jobs()
else:
err = ''.join(["No main command action called. \n",
"Please use '--generate' to create the job files. \n",
"or '--remove' to delete the job files. \n",
])
log.error(err)
raise RuntimeError(err)
def _cleanup(self):
try:
log.info(self.app_name + " complete.")
self.FH.close()
os.chmod(self.outfile, S_IREAD | S_IRGRP | S_IROTH)
except:
pass
def someflag(self):
try:
return self.SOMEFLAG
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A=str(stack()[0][3]))
log.info(err)
# raise ValueError(err)
return False
def main(self):
""""""
conn = Connect(*self.args, **self.kwargs)
paths = conn.meta.tables['path']
log.info("Writing to: '{F}'".format(F=str(self.outfile)))
FH = open(self.outfile, "w")
# FH.write(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + "\n")
nullnames = 0
for file in conn.ENGINE.execute(
"SELECT jobid, pathid, name FROM file"):
pathid = file[1]
jobid = file[0]
name = file[2]
if len(name) < 1:
nullnames += 1
continue
else:
if nullnames > 0:
log.info(
"Skipped {N} null filenames.".format(N=str(nullnames)))
nullnames = 0
path = conn.ENGINE.execute(
"SELECT path FROM path WHERE pathid = {P}".format(
P=str(pathid))).fetchone()[0]
_startend = conn.ENGINE.execute(
"SELECT starttime, realendtime FROM job WHERE jobid = {J}".
format(J=str(jobid))).fetchone()
_start = _startend[0].strftime('%Y-%m-%d')
# _end = _startend[1].strftime('%Y-%m-%d')
# startend = ''.join([_start, "-", _end])
line = ''.join(
[str(jobid), ":", _start, ":",
str(path) + str(name)])
# print(line) #333
try:
FH.write(line + "\n")
except UnicodeEncodeError as e:
line = line.encode('utf-8')
FH.write(str(line) + "\n")
FH.close()
def storage(self):
try: return self.STORAGE
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def priority(self):
try: return self.PRIORITY
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def messages(self):
try: return self.MESSAGES
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def level(self):
try: return self.LEVEL
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def incbackuppool(self):
try: return self.INCBACKUPPOOL
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def excdircontaining(self):
try: return self.EXCDIRCONTAINING
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def bootstrap(self):
try: return self.BOOTSTRAP
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def backup_type(self):
try: return self.TYPE
except (AttributeError, KeyError, ValueError) as e:
err = "Attribute {A} is not set. ".format(A = str(stack()[0][3]))
log.info(err)
raise ValueError(err)
def close(self):
log.info('DBHandler closed.')
def __init__(self, parser={}, *args, **kwargs):
self.app_name = self.__class__.__name__
if isinstance(parser, ArgumentParser):
### SET ALL ARGPARSE OPTIONS HERE #################################
### ALWAYS SET DEFAULTS THROUGH AN @property ######################
parser.add_argument(
'--logfile',
'-L',
action="store",
dest="logfile",
type=str,
help='Logfile file name or full path.\nDEFAULT: ./classname.log'
)
parser.add_argument('--loglevel',
'-E',
action="store",
dest="loglevel",
type=str,
help='Logging level.\nDEFAULT: 10.')
parser.add_argument(
'--screendump',
'-S',
action="store",
dest="screendump",
type=str,
help=
'For logging only. If "True" all logging info will also be dumped to the terminal.\nDEFAULT: True.'
)
parser.add_argument(
'--createpaths',
'-C',
action="store",
dest="createpaths",
type=str,
help=
'For logging only. If "True" will create all paths and files (example create a non-existent logfile.\nDEFAULT: True'
)
parser.add_argument(
'--user',
'-U',
action="store",
dest="user",
type=str,
default=None,
help=
"Database User for accessing the Bareos Postgres database. (DEFAULT: 'bareospostgresro')"
)
parser.add_argument(
'--password',
'-W',
action="store",
dest="password",
type=str,
default=None,
help=
"Database User's Password for accessing the Bareos Postgres database. (DEFAULT: 'None')"
)
parser.add_argument(
'--host',
'-H',
action="store",
dest="host",
type=str,
default=None,
help=
"Host for accessing the Bareos Postgres database. (DEFAULT: 'localhost')"
)
parser.add_argument(
'--port',
'-P',
action="store",
dest="port",
type=str,
default=None,
help=
"Port for accessing the Bareos Postgres database. (DEFAULT: '5432')"
)
parser.add_argument(
'--database',
'-D',
action="store",
dest="database",
type=str,
default=None,
help=
"Bareos Postgres database name to which to connect. (DEFAULT: 'bareos')"
)
parser.add_argument('--outfile',
'-o',
action="store",
dest="outfile",
type=str,
help='FULL PATH to outfile filename')
parser_kwargs = parser.parse_args()
kwargs.update(vars(parser_kwargs))
elif isinstance(parser, dict):
kwargs.update(parser)
else:
err = "{C}.{M}: Parameter 'parser' ({P}) must be either an Argparse parser object or a dictionary. ".format(
C=self.app_name, M=inspect.stack()[0][3], P=str(parser))
raise ValueError(err)
# Set classwide here
self.parser = parser
self.args = args
self.kwargs = kwargs
# # Here we parse out any args and kwargs that are not needed within the self or self.CONF objects
# # if "flag" in args: self.flag = something
### ALWAYS SET DEFAULTS IN @property #################################
# # Logging
self.logfile = kwargs.get("logfile",
''.join(["./", self.app_name, ".log"]))
self.log_level = kwargs.get("loglevel", 10)
self.screendump = kwargs.get("screendump", True)
self.create_paths = kwargs.get("createpaths", True)
#=== loghandler bugfix in Jessie access to self.socket.send(msg)
# Only use actual filesystem file for log for now
# Log something
log.info(
"Starting {C}...".format(C=self.app_name),
app_name=self.app_name,
logfile=self.logfile,
log_level=self.log_level,
screendump=self.screendump,
create_paths=self.create_paths,
)
# Start params here
### ALWAYS SET DEFAULTS THROUGH AN @property ######################
self.user = kwargs.get("user", None)
self.password = kwargs.get("password", None)
self.host = kwargs.get("host", None)
self.port = kwargs.get("port", None)
self.database = kwargs.get("database", None)
self.outfile = kwargs.get("outfile", None)
