import os import sys import psycopg2 from psycopg2 import sql from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT import uuid from datetime import datetime import pytz import sqlalchemy from sqlalchemy import URL import pandas as pd tz = pytz.timezone('Europe/Madrid') class Database(): name = 'fediverse database library' def __init__(self, config_file=None, mau_db=None, mau_db_user=None, mau_db_user_password=None): self.config_file = "config/db_config.txt" self.mau_db = self.__get_parameter("mau_db", self.config_file) self.mau_db_user = self.__get_parameter("mau_db_user", self.config_file) self.mau_db_user_password = self.__get_parameter("mau_db_user_password", self.config_file) db_setup = self.__check_dbsetup(self) if not db_setup: self.mau_db = input("\nMau database name: ") self.mau_db_user = input("\nMau database user: ") self.mau_db_user_password = input("\nMau database user password: ") self.__createdb(self) self.__create_config(self) self.__write_config(self) def get_nodeinfo_endpoint(self, server): try: conn = None conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") cur = conn.cursor() cur.execute("select server, api from servers where server=(%s)", (server,)) row = cur.fetchone() if row != None: server = row[0] api = row[1] else: server = '' api = '' cur.close() return (server, api) except (Exception, psycopg2.DatabaseError) as error: sys.exit(error) finally: if conn is not None: conn.close() def save_time(self, program, start, finish): insert_sql = "INSERT INTO execution_time(program, start, finish) VALUES(%s,%s,%s) ON CONFLICT DO NOTHING" conn = None try: conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") cur = conn.cursor() cur.execute(insert_sql, (program, start, finish,)) cur.execute("UPDATE execution_time SET start=(%s), finish=(%s) where program=(%s)", (start, finish, program)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def write_api(self, server, software, users, mau, alive, api, soft_version): now = datetime.now() insert_sql = "INSERT INTO fediverse(server, updated_at, software, users, mau, alive, users_api, version) VALUES(%s,%s,%s,%s,%s,%s,%s,%s) ON CONFLICT DO NOTHING" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() print(f'Writing {server} nodeinfo data...') cur.execute(insert_sql, (server, now, software, users, mau, alive, api, soft_version)) cur.execute( "UPDATE fediverse SET updated_at=(%s), software=(%s), users=(%s), mau=(%s), alive=(%s), users_api=(%s), version=(%s) where server=(%s)", (now, software, users, mau, alive, api, soft_version, server) ) cur.execute("UPDATE world SET checked='t' where server=(%s)", (server,)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def check_peer(self, server): found = False select_server_sql = 'select server from servers where server=(%s)' select_dead_server_sql = 'select server from deadservers where server=(%s)' try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() # check server cur.execute(select_server_sql, (server,)) row = cur.fetchone() if row != None: found = True cur.execute(select_dead_server_sql, (server,)) row = cur.fetchone() if row != None: found = True cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return found def get_not_updated_servers(self): not_updated_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() # get saved servers list cur.execute("select server from servers where updated_at is null") rows = cur.fetchall() for row in rows: not_updated_servers.append(row[0]) cur.close() print("Not updated servers: " + str(len(not_updated_servers))) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return not_updated_servers def get_saved_servers(self): saved_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() # get saved servers list cur.execute("select server from servers where api is not null") rows = cur.fetchall() for row in rows: saved_servers.append(row[0]) cur.close() print("Saved servers: " + str(len(saved_servers))) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return saved_servers def get_dead_servers(self): dead_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() # get dead servers list cur.execute("select server from deadservers") rows = cur.fetchall() for row in rows: dead_servers.append(row[0]) cur.close() print("Dead servers: " + str(len(dead_servers))) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return dead_servers def soft_totals(self): # get current total servers and users, get users from every software now = datetime.now() gettotals_sql = "select count(server), sum(users), sum(mau) from mau where alive" get_soft_totals_sql = "select software, sum(users) as users, sum(mau) as mau, count(server) as servers from mau where users != 0 and mau is not null and alive group by software order by mau desc" soft_total_project = [] soft_total_users = [] soft_total_mau = [] soft_total_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(gettotals_sql) row = cur.fetchone() total_servers = row[0] total_users = row[1] total_mau = row[2] cur.execute(get_soft_totals_sql) rows = cur.fetchall() for row in rows: soft_total_project.append(row[0]) soft_total_users.append(row[1]) soft_total_mau.append(row[2]) soft_total_servers.append(row[3]) cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (soft_total_project, soft_total_users, soft_total_mau, soft_total_servers, total_servers, total_users, total_mau) def get_last_checked_servers(self): # get last checked servers from fediverse DB alive_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() # get world servers list cur.execute("select server from world where server in (select server from fediverse where users_api != '')") rows = cur.fetchall() for row in rows: alive_servers.append(row[0]) cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return alive_servers def write_alive_server(self, server, software, version, users, mau, alive): now = datetime.now() insert_sql = "INSERT INTO mau(server, software, version, users, mau, alive, updated_at) VALUES(%s,%s,%s,%s,%s,%s,%s) ON CONFLICT DO NOTHING" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(insert_sql, (server, software, version, users, mau, alive, now)) cur.execute("UPDATE mau SET software=(%s), version=(%s), users=(%s), mau=(%s), alive=(%s), updated_at=(%s) where server=(%s)", (software, version, users, mau, alive, now, server)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def write_not_alive_server(self, server): now = datetime.now() update_sql = "UPDATE mau set alive='f', updated_at=(%s) where server=(%s)" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(update_sql, (now, server)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def write_server(self, server, api): now = datetime.now() insert_sql = "INSERT INTO servers(server, api, created_at, peers) VALUES(%s, %s, %s, %s) ON CONFLICT DO NOTHING" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(insert_sql, (server, api, now, False)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def write_deadserver(self, server): now = datetime.now() insert_sql = "INSERT INTO deadservers(server, checked_at) VALUES(%s,%s) ON CONFLICT DO NOTHING" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(insert_sql, (server, now)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def update_peer(self, server): now = datetime.now() update_sql = "UPDATE servers set peers=(%s), updated_at=(%s) where server=(%s)" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(update_sql, ('t', now, server)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def update_server(self, server, api): now = datetime.now() update_sql = "UPDATE servers set server=(%s), api=(%s), updated_at=(%s) where server=(%s)" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(update_sql, (server, api, now, server)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def soft_totals(self): # get current total servers and users, get users from every software now = datetime.now() gettotals_sql = "select count(server), sum(users), sum(mau) from mau where alive" get_soft_totals_sql = "select software, sum(users) as users, sum(mau) as mau, count(server) as servers from mau where users != 0 and mau is not null and alive group by software order by mau desc" soft_total_project = [] soft_total_users = [] soft_total_mau = [] soft_total_servers = [] try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(gettotals_sql) row = cur.fetchone() total_servers = row[0] total_users = row[1] total_mau = row[2] cur.execute(get_soft_totals_sql) rows = cur.fetchall() for row in rows: soft_total_project.append(row[0]) soft_total_users.append(row[1]) soft_total_mau.append(row[2]) soft_total_servers.append(row[3]) cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (soft_total_project, soft_total_users, soft_total_mau, soft_total_servers, total_servers, total_users, total_mau) def last_values(self, total_servers, total_users, total_mau): # get last check values and write current total ones now = datetime.now() evo_servers = 0 evo_users = 0 evo_mau = 0 select_sql = "select total_servers, total_users, total_mau from totals order by datetime desc limit 1" insert_sql = "INSERT INTO totals(datetime, total_servers, total_users, total_mau) VALUES(%s,%s,%s,%s)" try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(select_sql) row = cur.fetchone() if row is not None: servers_before = row[0] users_before = row[1] mau_before = row[2] else: servers_before = 0 users_before = 0 mau_before = 0 cur.execute(insert_sql, (now, total_servers, total_users, total_mau)) conn.commit() cur.close() evo_servers = total_servers - servers_before evo_users = total_users - users_before evo_mau = total_mau - mau_before except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (evo_servers, evo_users, evo_mau) def write_top_soft(self, soft_total_project, soft_total_users, soft_total_mau, soft_total_servers): now = datetime.now() insert_sql = "INSERT INTO top(datetime, software, users, mau, servers) VALUES(%s,%s,%s,%s,%s)" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(insert_sql, (now, soft_total_project, soft_total_users, soft_total_mau, soft_total_servers)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def write_evo(self, evo_servers, evo_users, evo_mau): # write evo values now = datetime.now() insert_sql = "INSERT INTO evo(datetime, servers, users, mau) VALUES(%s,%s,%s,%s)" conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute(insert_sql, (now, evo_servers, evo_users, evo_mau)) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def last_world_datetime(self): # get world's last update datetime conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select updated_at from world order by updated_at desc limit 1") row = cur.fetchone() last_update = row[0] last_update = last_update.strftime('%m/%d/%Y, %H:%M:%S') cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return last_update def max(self): # get max servers, max users and max mau conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select MAX(total_servers) from totals") row = cur.fetchone() if row is not None: max_servers = row[0] else: max_servers = 0 cur.execute("select MAX(total_users) from totals") row = cur.fetchone() if row is not None: max_users = row[0] else: max_users = 0 cur.execute("select MAX(total_mau) from totals") row = cur.fetchone() if row is not None: max_mau = row[0] else: max_mau = 0 cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (max_servers, max_users, max_mau) def get_plots(self): # get plots servers_plots = [] users_plots = [] mau_plots = [] global_day = [] global_servers = [] global_users = [] global_mau = [] global_week = [] global_week_users = [] global_week_mau = [] conn = None try: conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select total_servers, total_users, total_mau from totals order by datetime desc limit 14") rows = cur.fetchall() for row in rows: servers_plots.append(row[0]) users_plots.append(row[1]) mau_plots.append(row[2]) cur.execute("select distinct on (date_trunc('day', datetime)) datetime::TIMESTAMP::DATE, total_servers, total_users, total_mau from totals group by date_trunc('day', datetime), datetime") rows = cur.fetchall() for row in rows: global_day.append(row[0]) global_servers.append(row[1]) global_users.append(row[2]) global_mau.append(row[3]) cur.execute("select distinct on (date_trunc('week', datetime)) datetime::TIMESTAMP::DATE, total_users, total_mau from totals group by date_trunc('week', datetime), datetime") rows = cur.fetchall() for row in rows: global_week.append(row[0]) global_week_users.append(row[1]) global_week_mau.append(row[2]) cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (servers_plots, users_plots, mau_plots, global_day, global_servers, global_users, global_mau, global_week, global_week_users, global_week_mau) def get_server_data(self, server): was_alive = None software = None api = None soft_version = None first_checked_at = None downs_qty = None mau = 0 try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select alive, software, users_api, version, first_checked_at, downs, mau from fediverse where server=(%s)", (server,)) row = cur.fetchone() if row is not None: was_alive = row[0] software = row[1] api = row[2] soft_version = row[3] first_checked_at = row[4] downs_qty = row[5] mau = row[6] cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return (was_alive, software, api, soft_version, first_checked_at, downs_qty, mau) def get_soft_data(self, search_soft): try: conn = None conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") cur = conn.cursor() cur.execute("select count(server), sum(users), sum(mau) from mau where software=(%s) and alive", (search_soft,)) row = cur.fetchone() if row != None: servers = row[0] users = row[1] mau = row[2] else: servers = 0 users = 0 mau = 0 cur.close() return (servers, users, mau) except (Exception, psycopg2.DatabaseError) as error: sys.exit(error) finally: if conn is not None: conn.close() def fediquery_server_data(self, search_server): try: conn = None conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") cur = conn.cursor() cur.execute("select server, software, version, users, mau, alive from mau where server=(%s)", (search_server,)) row = cur.fetchone() if row != None: server = row[0] software = row[1] version = row[2] users = row[3] if row[4] != None: mau = row[4] else: mau = 0 alive = row[5] else: server = '' software = '' version = '' users = 0 mau = 0 alive = False cur.close() return (server, software, version, users, mau, alive) except (Exception, psycopg2.DatabaseError) as error: sys.exit(error) finally: if conn is not None: conn.close() def get_uptime(self): try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password=self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select count(server) from fediverse where alive") row = cur.fetchone() alive_servers = row[0] cur.execute("select MAX(date_trunc('day', last_checked_at) - date_trunc('days', first_checked_at)) from fediverse;") row = cur.fetchone() max_uptime = row[0] cur.execute("select count(server) from fediverse where date_trunc('days', last_checked_at)-date_trunc('days',first_checked_at)=(%s)", (max_uptime,)) row = cur.fetchone() if row is not None: best_servers = row[0] cur.execute("select software, count(*) as servers from fediverse where date_trunc('days',last_checked_at)-date_trunc('days', first_checked_at)=(%s) group by software order by servers desc", (max_uptime,)) rows = cur.fetchall() software_lst = [] servers_lst = [] for row in rows: software_lst.append(row[0]) servers_lst.append(row[1]) cur.close() return (alive_servers, max_uptime, best_servers, software_lst, servers_lst) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def get_percentage(self, uptime_servers, software): try: conn = None conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password=self.mau_db_user_password, host="/var/run/postgresql", port="5432") cur = conn.cursor() cur.execute("select count(server) from fediverse where alive and software=(%s)", (software,)) row = cur.fetchone() if row is not None: soft_total_servers = row[0] cur.close() soft_uptime_percent = round((uptime_servers * 100) / soft_total_servers, 1) return (soft_uptime_percent) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def csv_save(self, filename): is_saved = False url_object = URL.create( "postgresql+psycopg2", username=self.mau_db_user, password=self.mau_db_user_password, host="localhost", database=self.mau_db, ) sql = "select * from mau where alive order by mau desc" conn = None try: conn = sqlalchemy.create_engine(url_object) with conn.connect() as connection: dataframe = pd.read_sql_query(sql, conn) dataframe.to_csv(filename, sep='|', header=True, index=False) is_saved = True except (Exception, psycopg2.DatabaseError) as error: print(error) return is_saved @staticmethod def __check_dbsetup(self): db_setup = False try: conn = None conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") db_setup = True except (Exception, psycopg2.DatabaseError) as error: print(error) return db_setup @staticmethod def __createdb(self): conn = None try: conn = psycopg2.connect(dbname='postgres', user=self.mau_db_user, host='', password=self.mau_db_user_password) conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT) cur = conn.cursor() print(f"Creating database {self.mau_db}. Please wait...") cur.execute(sql.SQL("CREATE DATABASE {}").format( sql.Identifier(self.mau_db)) ) print(f"Database {self.mau_db} created!\n") self.__dbtables_schemes(self) except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() @staticmethod def __dbtables_schemes(self): db = self.mau_db table = "mau" sql = "create table "+table+" (server varchar(200) PRIMARY KEY, software varchar(50), version varchar(50), users int, mau int, alive boolean, updated_at timestamptz)" self.__create_table(self, table, sql) table = "servers" sql = "create table "+table+" (server varchar(200) PRIMARY KEY, api varchar(50), created_at timestamptz, peers boolean, updated_at timestamptz)" self.__create_table(self, table, sql) table = "deadservers" sql = "create table "+table+" (server varchar(200) PRIMARY KEY, checked_at timestamptz)" self.__create_table(self, table, sql) table = "totals" sql = "create table "+table+" (datetime timestamptz PRIMARY KEY, total_servers INT, total_users INT, total_mau INT)" self.__create_table(self, table, sql) table = "evo" sql = "create table "+table+" (datetime timestamptz PRIMARY KEY, servers INT, users INT, mau INT)" self.__create_table(self, table, sql) table = "top" sql = "create table "+table+" (datetime timestamptz PRIMARY KEY, software varchar(50), users INT, mau INT, servers INT)" self.__create_table(self, table, sql) table = "execution_time" sql = "create table "+table+" (program varchar(20) PRIMARY KEY, start timestamptz, finish timestamptz)" self.__create_table(self, table, sql) @staticmethod def __create_table(self, table, sql): conn = None try: conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "5432") cur = conn.cursor() print(f"Creating table {table}") cur.execute(sql) conn.commit() print(f"Table {table} created!\n") except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() def __get_parameter(self, parameter, config_file): if not os.path.isfile(config_file): print(f"File {config_file} not found..") return with open( config_file ) as f: for line in f: if line.startswith( parameter ): return line.replace(parameter + ":", "").strip() print(f"{config_file} Missing parameter {parameter}") sys.exit(0) @staticmethod def __create_config(self): if not os.path.exists('config'): os.makedirs('config') if not os.path.exists(self.config_file): print(self.config_file + " created!") with open(self.config_file, 'w'): pass @staticmethod def __write_config(self): with open(self.config_file, 'a') as the_file: the_file.write(f'mau_db: {self.mau_db}\nmau_db_user: {self.mau_db_user}\nmau_db_user_password: {self.mau_db_user_password}') print(f"adding parameters to {self.config_file}\n")