def load_latest_db(self, dbs: Optional[DBS] = None) -> None: """ load_latest_db Args: dbs (Optional[DBS]): db Returns: None """ if dbs is None: try: ldb: DBSCredentials = self.local_db.get_latest_db() self.dbs = DBS(ldb) self.response['database'] = { 'name': ldb.get_name(), 'id': ldb.get_id() } except DbNotFoundException as ex: log_objects(ex) self.response['status'] = self.STATUS_NO_DB self.response['message'] = Translator().translate("db_choose") raise PayloadException(self.response['message'], self.response) except Exception as ex: log_objects(ex) self.response['status'] = self.STATUS_ERROR self.response['message'] = Translator().translate(str(ex)) raise PayloadException(self.response['message'], self.response) else: self.dbs = dbs
def run() -> None: """ run - autoinstall program, add dir with data or leave if done already Returns: None """ try: crypto_key: str = Program.get_crypto_key() return crypto_key except FileNotFoundError: try: ''' create our .sdba directory ''' Program.sdba_apath.mkdir() except FileExistsError: pass ''' create new Directory with encyption salt file ''' try: crypto_key: str = Program.generate_crypto_key() Program.saltf_path.touch() saltfile_path = Path(Program.saltf_path) saltfile_path.write_bytes(crypto_key) except Exception as ex: log_objects(ex)
def get_all_variables(self) -> Dict[str, Tuple[Any, ...]]: """ get_all_variables Returns: Dict[str, Tuple[Any, ...]]: dict """ html: HtmlIzer = HtmlIzer() try: global_v = self.get_global_variables() session_v = self.get_session_variables() keys = list(set().union(global_v, session_v)) _res: Dict[str, Any] = {} for ki in keys: l, g = "-", "-" if ki in session_v: l = html.wrap_types(session_v[ki]) if ki in global_v: g = html.wrap_types(global_v[ki]) _res[ki] = (l, g) return _res except Exception as e: log_objects(e) raise e
def set_latest_db(self, db: DBSCredentials) -> None: """ set_latest_db Args: db (DBSCredentials): db Returns: None """ try: Q = Query() check = not not self.tdb_tbl_latest_dbs.search(Q.last_db_id == 1) if not check: # add record self.tdb_tbl_latest_dbs.insert({ 'last_db_id': 1, 'id': db.get_id() }) else: # only update self.tdb_tbl_latest_dbs.update({'id': db.get_id()}, Q.last_db_id == 1) except Exception as e: log_objects(e)
def add_new_database(self, name: str, host: str, user: str, password: str, port: int = 3306, type: DBSCredentials.TYPE = DBSCredentials.TYPE.MYSQL, ssl: bool = False) -> Dict[str, Any]: """ add_new_database Args: name (str): host (str): user (str): password (str): port (int): type (DBSCredentials.TYPE): ssl (bool): Returns: bool """ local_db: TinyDBS = TinyDBS() if Utils.strempty(name) or Utils.strempty(host) or Utils.strempty( user): self.response['status'] = self.STATUS_ERROR self.response['message'] = Translator().translate( "inforrect_db_data") raise PayloadException(self.response['message'], self.response) last_id: int = local_db.get_last_db_id() + 1 new_db_cred: DBSCredentials = DBSCredentials(last_id, name, host, user, password, port, type, ssl) try: local_db.add_new_db(new_db_cred) if last_id == 1: local_db.set_latest_db(new_db_cred) self.response['database'] = { 'name': new_db_cred.get_name(), 'id': new_db_cred.get_id() } else: self.load_latest_db() self.response['message'] = Translator().translate("success") return self._get_response() except Exception as e: log_objects(e) return self._get_response()
def get_slave_status(self) -> Dict[str, Any]: """ get_slave_status Returns: Dict[str, Any]: dict """ try: result = self.db.fetchOne(self.get_slave_status_sql, DSBFetchTypes.ASSOC) return result except Exception as e: log_objects(e) raise e
def get_result(self) -> Any: # MonitorLogResult """ get_result Returns: Any """ # temporary commented # (always retur new result) # if self.result_composed is not None: # return self.result_composed log_objects(self) return self._prepare_result()
def __init__(self) -> None: """ __init__ """ try: self.hasher = Hasher() self.tdb_db = TinyDB(Program.sdba_apath.joinpath(self._DATA_FILE)) self.tdb_tbl_databases = self.tdb_db.table('databases') self.tdb_tbl_latest_dbs = self.tdb_db.table('tdb_tbl_latest_dbs') except Exception as e: log_objects(e) raise e
def decode_data(self, strdata: Any) -> Any: """ decode_data Args: strdata (Any): Returns: Any """ hasher_tag: str = self.WRAP_REGEX.split('{')[0] def decode(estr: str) -> str: try: if hasher_tag not in str(estr): return estr else: patters: str = self.WRAP_REGEX.replace("{", "").replace( "}", "") m = re.search(patters, estr) if m: found = m.group(1) return self._unhash(found) elif estr == self.WRAP_REGEX.replace("{(.+?)}", ""): return "" else: return estr return estr except Exception as ex: log_objects(ex) try: if isinstance(strdata, dict): ndct = {} for k, v in strdata.items(): if isinstance(v, dict): ndct[k] = v else: ndct[k] = decode(v) return ndct else: return decode(strdata) except Exception as e: log_objects(e)
def is_number(n: str) -> bool: """ is_number Args: n (str): - Returns: bool: True - yes, False - no """ try: float(n) except ValueError as e: return False except Exception as e: log_objects(e) return True
def __fetch( self, query: str, fetch_num: DBSFetchNum = DBSFetchNum.ALL, fetch_type: DSBFetchTypes = DSBFetchTypes.ROW, params: Tuple[Union[str, int, float]] = () ) -> Union[List[Dict[str, Any]], Dict[str, Any]]: """ __fetch Args: query (DBSFetchNum): - fetch_num (DSBFetchTypes): - fetch_type (Tuple[Union[str, int, float]]): - params (Tuple[Union[str, int, float]]): - Returns: Union[List[Dict[str, Any]], Dict[str, Any]] """ log_objects(QueryLog(query, params)) cursor = self._connection.cursor() cursor.execute(query, params) if fetch_num == DBSFetchNum.ONE: res = cursor.fetchone() else: res = cursor.fetchall() if res is None: res = [] if fetch_type == DSBFetchTypes.ROW: return res else: if fetch_num == DBSFetchNum.ONE: res = [res] fields = [column[0] for column in cursor.description] result = [dict(line) for line in [zip(fields, row) for row in res]] if fetch_num == DBSFetchNum.ONE: return result[0] return result
def _get_innodb_status(self) -> str: """ _get_innodb_status Returns: None """ try: # with open('../test-monitor.txt', 'r') as f2: # log_str = f2.read() # return log_str res = self.db.fetchOne(self._get_innodb_status_sql) return res[2] except Exception as e: log_objects(e) raise e
def find_between_rindex(s, first, last) -> str: """ find_between_rindex Args: s (): first (): last (): Returns: str """ try: start = s.rindex(first) + len(first) end = s.rindex(last, start) return s[start:end] except ValueError: return "" except Exception as e: log_objects(e)
def get_xpath_dict_value(dict: Dict[Any, Any], *key_pa) -> Any: """ get_xpath_dict_value Args: dict (Dict[Any, Any]): - *key_pa (): Returns: Any """ ik = key_pa[0] if type(dict[ik]) == type({}) and len(key_pa) > 1: try: return Monitor.get_xpath_dict_value(dict[ik], *key_pa[1:]) except IndexError as e: log_objects(e) except Exception as e: log_objects(e) else: return dict[ik]
def decode(estr: str) -> str: try: if hasher_tag not in str(estr): return estr else: patters: str = self.WRAP_REGEX.replace("{", "").replace( "}", "") m = re.search(patters, estr) if m: found = m.group(1) return self._unhash(found) elif estr == self.WRAP_REGEX.replace("{(.+?)}", ""): return "" else: return estr return estr except Exception as ex: log_objects(ex)
def add_new_db(self, db: DBSCredentials) -> None: """ add_new_db Args: db (DBSCredentials): Returns: None """ try: db_cred = db.get_as_dict() hashed_data = self.hasher.encode_data(db_cred) ''' endode credentials before save to tiny DB ''' data = {'id': db_cred['id'], 'hashed_data': hashed_data} self.tdb_tbl_databases.insert(data) except Exception as e: log_objects(e) raise e
def __init__(self, credentials=None) -> None: """ __init__ """ try: mysql_con = MySQLConnection() mysql_con.connect(host=credentials.get_host(), user=credentials.get_user(), passwd=credentials.get_password()) self._connected = True self._connection = mysql_con except Error as e: log_objects(e) raise e finally: pass
def __call__(self, posarg, *args, **kwargs) -> Any: """ __call__ Args: posarg (): - *args (): - **kwargs (): - Returns: Any """ key: str = (self.__func, posarg, args[1:], frozenset(kwargs.items())).__str__() try: if self.__predicate() == False: raise KeyError() res = self.__cache[key] except KeyError: res = self.__cache[key] = self.__func(posarg, *args, **kwargs) except Exception as e: log_objects(e) return res
def set_xpath_dict_value(dict: Dict[Any, Any], val, *key_pa) -> None: """ set_xpath_dict_value Args: dict (Dict[Any, Any]): val (): *key_pa (): Returns: None """ ik = key_pa[0] if type(dict[ik]) == type({}) and len(key_pa) > 1: try: return Monitor.set_xpath_dict_value(dict[ik], val, *key_pa[1:]) except IndexError as e: log_objects(e) pass except Exception as e: log_objects(e) raise IndexError else: dict[ik] = val
def __init__(self) -> None: log_objects(self)