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)