def discover_cluster_databases(self,make_observable=True):
if not self.__prod_conn:
if not self.__set_self_db_conn():
logger.error("Did not obtain Prod database conection for cluster {0} in discover_cluster_databases method ".format(self.db_fields['hostname']))
return
cur=self.__prod_conn.cursor()
try:
cur.execute("SELECT oid,datname FROM pg_database WHERE NOT datistemplate AND datname !='postgres'")
except Exception as e:
logger.error("Cannot execute database discovery query: {0}".format(e))
cur.close()
return
prod_dbs=cur.fetchall()
cur.close()
self.cursor.execute("SELECT obj_oid,db_name,id FROM database_name WHERE hc_id={0} AND alive".format(self.id))
local_dbs=self.cursor.fetchall()
for l_db in local_dbs:
for p_db in prod_dbs:
if l_db[0]==p_db[0] and l_db[1]==p_db[1]:
break
else:
old_db=DatabaseName(l_db[2],self.return_conn_string(dbname=l_db[1]))
old_db.retire()
logger.info("Retired database {0} in cluster {1}".format(l_db[1],self.db_fields['hostname']))
for p_db in prod_dbs:
for l_db in local_dbs:
if l_db[0]==p_db[0] and l_db[1]==p_db[1]:
break
else:
new_db=DatabaseName()
new_db.set_fields(hc_id=self.id,obj_oid=p_db[0],db_name=p_db[1],observable=make_observable)
new_db.create()
new_db.truncate()
logger.info("Create new database {0} for cluster {1}".format(p_db[1],self.db_fields['hostname']))
def runtime_stat(self, in_time_id):
if not super(HostCluster, self).runtime_stat(in_time_id):
logger.error("Returned from HC.runtime_stat")
return False
dep_dn = self.get_dependants(True)
if not dep_dn:
logger.error("Returned from HC.runtime_stat no dependants returned")
return False
for dn_set in dep_dn:
dn = DatabaseName(self.db_conn, dn_set["db_dsn"], dn_set["id"])
if not dn.runtime_stat(in_time_id):
logger.error("Error in HC.runtime_stat False from db.stat")
dn.__del__()
return True
lt=LogTime()
work_cursor=database.db_conn.cursor()
work_cursor.execute("SELECT id FROM host_cluster WHERE alive AND observable")
for hc_id in work_cursor.fetchall():
hc=HostCluster(hc_id[0])
hc.discover_cluster_params()
hc.stat(lt.id)
for dbs in hc.get_dependants(obs=True):
db_conn_string=hc.return_conn_string(dbs['db_name'])
dn=DatabaseName(dbs['id'],db_conn_string)
dn.stat(lt.id)
db_cursor=dn.get_prod_cursor()
if db_cursor:
for sn_id in dn.get_dependants(obs=True):
sn=SchemaName(sn_id)
sn.discover_tables(db_cursor)
sn.discover_functions(db_cursor)
for tbl_id in sn.get_tables():
tn=TableName(tbl_id)
tn.stat(lt.id,db_cursor)
tn.va_stat(lt.id,db_cursor)
tn.discover_indexes(db_cursor)
for ind_id in tn.get_dependants():
ind=IndexName(ind_id)
ind.stat(lt.id,db_cursor)
def discover_databases(self):
p_cur = self._get_p_cursor()
if not p_cur:
logger.error("Return from discover_databases. No p_cur obtained")
return False
try:
p_cur.execute("SELECT oid,datname FROM pg_database WHERE NOT datistemplate AND datname !='postgres'")
except Exception as e:
logger.error("Cannot execute database discovery query on Prod: {0}".format(e.pgerror))
p_cur.close()
return False
prod_dbs = p_cur.fetchall()
p_cur.close()
cur = self._get_cursor()
if not cur:
logger.error("Return from discover_databases. No cur obtained")
return False
cur = self.db_conn.cursor()
try:
cur.execute("SELECT obj_oid,db_name,id FROM database_name WHERE hc_id={0} AND alive".format(self.id))
except Exception as e:
logger.error("Cannot execute database discovery query on Local: {0}".format(e.pgerror))
cur.close()
return False
local_dbs = cur.fetchall()
cur.close()
for l_db in local_dbs:
for p_db in prod_dbs:
if l_db[0] == p_db[0] and l_db[1] == p_db[1]:
old_db = DatabaseName(self.db_conn, self.get_conn_string(l_db[1]), l_db[2])
if not old_db.discover_schemas():
logger.error("HC.discover_databases. False from discover_schemas() for old")
old_db.__del__()
break
else:
old_db = DatabaseName(self.db_conn, self.get_conn_string(l_db[1]), l_db[2])
if old_db.retire():
logger.info("Retired database {0} in cluster {1}".format(l_db[1], self.db_fields["hostname"]))
else:
logger.error("HC.discover_databases() cannot retire old")
old_db.__del__()
for p_db in prod_dbs:
for l_db in local_dbs:
if l_db[0] == p_db[0] and l_db[1] == p_db[1]:
break
else:
new_db = DatabaseName(self.db_conn, self.get_conn_string(p_db[1]))
new_db.set_fields(hc_id=self.id, obj_oid=p_db[0], db_name=p_db[1])
if new_db._create():
logger.info("Create new database {0} for cluster {1}".format(p_db[1], self.db_fields["hostname"]))
if not new_db.discover_schemas():
logger.error("HC.discover_databases. False from discover_schemas() for new")
else:
logger.error("HC.discover_databases(). Canot create new")
new_db.__del__()
return True
