def __init__(self, parser={}, *args, **kwargs): # Always set the defaults via the @property super().__init__(parser, *args, **kwargs) # We connect with the help of the PostgreSQL URL # postgresql://federer:grandestslam@localhost:5432/tennis url = 'postgresql://{}:{}@{}:{}/{}' url = url.format(self.user, self.password, self.host, self.port, self.database) # The return value of create_engine() is our connection object try: self.engine = sqlalchemy.create_engine(url, client_encoding='utf8') except Exception as e: err = "Unable to create Postgres engine with user = '******', password = '******', host= '{H}', port = '{O}', database = '{D}'".format( U=self.user, P=obfpwd(self.password), H=self.host, O=self.port, D=self.database) log.error(err) raise RuntimeError(err) with warnings.catch_warnings(): warnings.simplefilter("ignore", category=sa_exc.SAWarning) try: self.meta = sqlalchemy.MetaData(bind=self.engine, reflect=True) except Exception as e: err = "Unable to create Postgres Meta object from SQLAlchemy engine '{E}'".format( E=str(self.engine)) log.error(err) raise RuntimeError(err)
def database(self): try: return self.DATABASE except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
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 someparam(self): try: return self.SOMEPARAM except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def log_level(self): try: return self.LOGLEVEL except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def port(self): try: return self.PORT except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def screendump(self): try: return self.SCREENDUMP except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def create_paths(self): try: return self.CREATEPATHS except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def meta(self, value): if isinstance(value, sqlalchemy.sql.schema.MetaData): self.META = value else: err = "Value '{V}'does not appear to be a valid 'sqlalchemy.sql.schema.MetaData' object".format( V=type(value)) log.error(err) raise ValueError(err)
def meta(self): try: return self.META except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. Try the 'connection' method. ".format( A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def outfile(self): try: return self.OUTFILE except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set and cannot be null. ".format( A=str(stack()[0][3])) log.error(err) raise ValueError(err)
def engine(self, value): if isinstance(value, sqlalchemy.engine.base.Engine): self.ENGINE = value else: err = "Value '{V}'does not appear to be a valid 'sqlalchemy.engine.base.Engine' object".format( V=type(value)) log.error(err) raise ValueError(err)
def generate(self, value): if value is None: if self.directory is None or self.directory == "": err = "The Attribute 'directory' cannot be 'None' when using the 'generate' switch. Please specify the directory from which to generate backup config files. " log.error(err) raise RuntimeError(err) if value: self.GENERATE = True else: self.GENERATE = False
def director_path(self, value): if value is None: value = "/etc/bareos/bareos-dir.d" _value = str(value) _value = _value if _value.endswith(_delim) else _value + _delim # Do checks and such here if (not os.path.isdir(_value)): err = "Attribute '{A}. '{V}' does not appear to exist or is not readable.".format(A = str(stack()[0][3]), V = _value) log.error(err) raise ValueError(err) else: self.DIRECTORPATH = _value
def port(self, value): if value is None: value = "5432" _value = str(value) # Do checks and such here if (not _value): err = "Attribute '{A} = {V}' does not appear to be valid.".format( A=str(stack()[0][3]), V=_value) log.error(err) raise ValueError(err) else: self.PORT = _value
def user(self, value): if value is None: value = "bareospostgresro" _value = str(value) # Do checks and such here if (not _value): err = "Attribute '{A} = {V}' does not appear to be valid.".format( A=str(stack()[0][3]), V=_value) log.error(err) raise ValueError(err) else: self.USER = _value
def someparam(self, value): if value is None: value = "MyParam" _value = str(value) # Do checks and such here if (not _value): err = "Attribute '{A} = {V}' does not appear to be valid for reason.".format( A=str(stack()[0][3]), V=_value) log.error(err) raise ValueError(err) else: self.SOMEPARAM = _value
def database(self, value): if value is None: value = "bareos" _value = str(value) # Do checks and such here if (not _value): err = "Attribute '{A} = {V}' does not appear to be valid.".format( A=str(stack()[0][3]), V=_value) log.error(err) raise ValueError(err) else: self.DATABASE = _value
def handler(service, *args, **kwargs): # Microsoft SQL (mssql) if re.match("^(\s*)ms(\s*)sql.*$", str(service.lower())): return DBHandler_MSSQL(*args, **kwargs) # MySQL elif re.match("^(\s*)my(\s*)sql.*$", str(service.lower())): return DBHandler_MYSQL(*args, **kwargs) else: log.error(MSG.DBHandlerNotProvided()) raise TypeError('DBHandler service not provided.')
def directory(self, value): if value is None: err = "Parameter '{A}' has been set to 'None'. This may cause an error for certain operations.".format(A = str(stack()[0][3])) log.warning(err) self.DIRECTORY = value return # raise ValueError(err) _value = str(value) # Do checks and such here if (not os.path.isdir(_value)): err = "Attribute '{A}. '{V}' does not appear to exist or is not readable.".format(A = str(stack()[0][3]), V = _value) log.error(err) raise ValueError(err) else: self.DIRECTORY = _value
def _check_db_name(self): try: # Errors if it doesnt exist self.config.db_name # Overrides self.config.db_host if it was passed in self.config.db_name = self.kwargs.pop("db_name", self.config.db_name) except AttributeError as e: log.error(MSG.DBNameNotConfigured()) self.config.db_name = self.default.db_name if (checkString(self.config.db_name) is False): log.error(MSG.DBNameImproperlyConfigured()) raise AttributeError("Invalid database name '" + str(self.config.db_name) + "'") log.debug('DBHandler.db_name: ' + str(self.config.db_name))
def _check_db_port(self): try: # Errors if it doesnt exist self.config.db_port # Overrides self.config.db_host if it was passed in self.config.db_port = self.kwargs.pop("db_port", self.config.db_port) except AttributeError as e: log.error(MSG.DBPortNotConfigured()) self.config.db_port = self.default.db_port if (checkInt(self.config.db_port) is False): log.error(MSG.DBPortImproperlyConfigured()) raise AttributeError("Invalid database port '" + str(self.config.db_port) + "'") log.debug('DBHandler.db_port: ' + str(self.config.db_port))
def _check_host(self): try: # Errors if it doesnt exist self.config.db_host # Overrides self.config.db_host if it was passed in self.config.db_host = self.kwargs.pop("db_host", self.config.db_host) except AttributeError as e: log.error(MSG.DBHostNotConfigured()) self.config.db_host = self.default.db_host if ((checkIP(self.config.db_host) is False) and (checkServername(self.config.db_host) is False)): log.error(MSG.DBHostImproperlyConfigured()) raise AttributeError("Invalid database host name '" + str(self.config.db_host) + "'") log.debug('DBHandler.db_host: ' + str(self.config.db_host))
def controlled_delete(self, p): _p = str(p) msg = "DELETING FILE: '{P}'".format(P = _p) if self.test: msg += "(test only)" log.warning(msg) filename = ntpath.basename(_p) lastdir = ntpath.dirname(_p) lastdir = lastdir.split(_delim) lastdir = lastdir[len(lastdir)-1] tmpdir = os.path.join(tempfile.gettempdir(), "bareos_director_deletes", lastdir) if not os.path.isdir(tmpdir): try: os.makedirs(tmpdir) except Exception as e: err = "Unable to create 'deletion' directory '{D}'. Aborting delete. Please remove files manually. (ERR: {E}".format(D = tmpdir, E = str(e)) log.error(err) raise RuntimeError(err) dst = os.path.join(tmpdir, filename) # print("Copy from '{P}' to '{D}'".format(P = _p, D = dst) ) msg = "copyfile({P}, {D})' ...".format(P = str(p), D = dst) if self.test: msg += "OK (test only)" else: try: copyfile(str(p), dst) msg += "OK" log.debug(msg) except Exception as e: msg += "FAILED! (ERROR: {E})".format(E=str(e)) log.error(msg) msg = "{P}.unlink ...".format(P = str(p)) if self.test: msg += "OK (test only)" else: try: p.unlink() msg += "OK" log.debug(msg) except Exception as e: msg += "FAILED! (ERROR: {E})".format(E=str(e)) log.error(msg)
str(e), "). " ])) # Sends the message and original error to the LOGGER # _log_error(message, e) ### METHOD ACTIONS # raise FatalException(e) # Does not return return args, kwargs, None # FOR UNITTEST if __name__ == '__main__': import inspect from common.loghandler import log log.error("Starting handlers unittest. Ignore errors from 'handlers_unittest_ignore_me'", app_name = 'handlers_unittest_ignore_me', logfile = 'system', log_level = 10, screendump = False ) class test(): def __init__(self): pass # Set 'e' try: this_error_was_passed_in_to_handler except Exception as pass_in_err: pass callobj = test() args = ('a', 0)
def symlinks(self): try: return self.SYMLINKS except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A = str(stack()[0][3])) log.error(err) raise ValueError(err)
def customErr(self, callobj, args, kwargs, e, source, frame): """ NAME errorhandler FILE errorhandler.py DESCRIPTION Used for generating both custom unhandled exceptions, and for handling exceptions with specific actions. Creates the opportunity for cutom code to be attached to errors and resolve them in a clean format An existing 'self' object must be passed in with an existing self.log object associated with it!! Uses the self.log() parameter of an EXISTING instantiated log object to generate output. A logger has to be instantiated in the calling class for this method to be used. EXAMPLE (USAGE) from inspect import getmembers from inspect import stack import errorhandler customerr = errorhandler.ErrorHandler(self.log) self.err = customerr.err() try: print this wont work except: e = "".join(["ErrorIdentifier: ", "Additional information."]) self.lasterr = self.err(e, getmembers(self), stack()) METHODS ErrorHandler(self, e, source, frame) Error message handler. Generates logfile output self = The class object using the error handler. Must contain a self.log object. e = The error message passed from the calling object. I.e. except Exception, e: source = The inspect.getmembers(self) passed in from the error call. frame = The inspect.stack() passed in from the error call. TEMPLATE(self, e) Create custom error message and handling code HIDDEN METHODS _format_original_error(e) _log_error(self, message, e) """ ############################################################################### # FOR NOW, LEAVE 'e' ALONE # # Source is inspect.getmembers(self) # # EXAMPLE SOURCE (a list of tuples): # #[('MAX_LENGTH', 16384), # # ('TSTART', 'TWILIOSOCK'), # # ('__doc__', None), # # ('__implemented__', <implementedBy twisted.internet.protocol.Protocol>), # # ('__init__', <bound method Handler.__init__ of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('__module__', 'twistedlisten'), # # ('__providedBy__', <implementedBy twistedlisten.Handler>), # # ('__provides__', <implementedBy twistedlisten.Handler>), # # ('_buffer', ''), # # ('_busyReceiving', False), # # ('_checkdata', <bound method Handler._checkdata of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('_parsedata', <bound method Handler._parsedata of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('<some_method>', <bound method <class>.<method> of <someinstance instance at 0x02E05EB8>>), # #] # errorin = str(source[6][1]) # errorin = errorin.replace("implementedBy", "") # errorin = "".join(c for c in errorin if c not in "<>") # errorin = errorin + "." + str(frame[0][3]) # errorin = errorin + "(line:" + str(frame[0][2]) + "): " # e = errorin + str(e) # import handlers #333 # This calls the proper handler method from 'handlers' # NOTE: The error keyword MUST MATCH THE METHOD NAME # NOTE: A string search is used to match the method name to contents # of the error string passed in. # THIS MEANS if you have two methods, 'ERR1' AND 'ERR10', 'ERR1' # will always be the one found...SO IT IS RECOMMENDED YOU NAME # THE METHODS VERY UNIQUELY AND CAREFULLY. # I.e. 'StringNotFoundInLogError' for key in Handlers.__dict__.keys(): if (str(key).lower() in str(e).lower()): return Handlers.__dict__[key](callobj, args, kwargs, e) log.error(''.join([ "errorhandler.customErr: ", "Didn't find a matching handler for ", str(callobj), ",", str(args), ",", str(kwargs), ",", str(e) ])) key = "UnknownException" # return Handlers.UnknownException(callobj, args, kwargs, e) return Handlers.__dict__[key](callobj, args, kwargs, e)
def director_path(self): try: return self.DIRECTORPATH except (AttributeError, KeyError, ValueError) as e: err = "Attribute {A} is not set. ".format(A = str(stack()[0][3])) log.error(err) raise ValueError(err)
def _log_error(message, e): # Format message e = "".join([str(_format_original_error(e)), message]) # Send to log log.error(e) return