diff --git a/src/telemetry/database/TelemetryDBmanager.py b/src/telemetry/database/TelemetryDBmanager.py index 42d647e0d660a2040b4d025f5316c6e073c70e1e..0380bc8ee643bc51ff1a3be39ddd7194fbebaa65 100644 --- a/src/telemetry/database/TelemetryDBmanager.py +++ b/src/telemetry/database/TelemetryDBmanager.py @@ -20,7 +20,7 @@ from telemetry.database.TelemetryModel import Kpi as KpiModel from sqlalchemy.ext.declarative import declarative_base from telemetry.database.TelemetryEngine import TelemetryEngine from common.proto.kpi_manager_pb2 import KpiDescriptor, KpiId -from common.proto.telemetry_frontend_pb2 import Collector +from common.proto.telemetry_frontend_pb2 import Collector, CollectorId from sqlalchemy.exc import SQLAlchemyError @@ -65,6 +65,8 @@ class TelemetryDBmanager: except Exception as e: LOGGER.info("Unable to fetch Table names. {:s}".format(str(e))) +# ------------------ INSERT METHODs -------------------------------------- + def inser_kpi(self, request: KpiDescriptor): session = self.Session() try: @@ -114,16 +116,18 @@ class TelemetryDBmanager: # Close the session session.close() - def get_kpi_descriptor(self, kpi_id: KpiId): +# ------------------ GET METHODs -------------------------------------- + + def get_kpi_descriptor(self, request: KpiId): session = self.Session() try: - kpi_id_to_get = kpi_id.kpi_id.uuid - kpi = session.query(KpiModel).filter_by(kpi_id=kpi_id_to_get).first() + kpi_id_to_search = request.kpi_id.uuid + kpi = session.query(KpiModel).filter_by(kpi_id=kpi_id_to_search).first() if kpi: LOGGER.info("kpi ID found: {:s}".format(str(kpi))) return kpi else: - LOGGER.info("Kpi ID not found{:s}".format(str(kpi_id_to_get))) + LOGGER.warning("Kpi ID not found{:s}".format(str(kpi_id_to_search))) return None except Exception as e: session.rollback() @@ -131,7 +135,27 @@ class TelemetryDBmanager: raise finally: session.close() + + def get_collector(self, request: CollectorId): + session = self.Session() + try: + collector_id_to_search = request.collector_id.uuid + collector = session.query(CollectorModel).filter_by(collector_id=collector_id_to_search).first() + if collector: + LOGGER.info("collector ID found: {:s}".format(str(collector))) + return collector + else: + LOGGER.warning("collector ID not found{:s}".format(str(collector_id_to_search))) + return None + except Exception as e: + session.rollback() + LOGGER.info("Failed to retrieve collector ID. {:s}".format(str(e))) + raise + finally: + session.close() + # ------------------ SELECT METHODs -------------------------------------- + def select_kpi_descriptor(self, **filters): session = self.Session() try: @@ -144,5 +168,56 @@ class TelemetryDBmanager: except SQLAlchemyError as e: LOGGER.error("Error fetching filtered rows from KPI table with filters {:}: {:}".format(filters, e)) return [] + finally: + session.close() + + def select_collector(self, **filters): + session = self.Session() + try: + query = session.query(CollectorModel) + for column, value in filters.items(): + query = query.filter(getattr(CollectorModel, column) == value) + result = query.all() + LOGGER.info("Fetched filtered rows from KPI table with filters ---------- : {:s}".format(str(result))) + return result + except SQLAlchemyError as e: + LOGGER.error("Error fetching filtered rows from KPI table with filters {:}: {:}".format(filters, e)) + return [] + finally: + session.close() + +# ------------------ DELETE METHODs -------------------------------------- + + def delete_kpi_descriptor(self, request: KpiId): + session = self.Session() + try: + kpi_id_to_delete = request.kpi_id.uuid + kpi = session.query(KpiModel).filter_by(kpi_id=kpi_id_to_delete).first() + if kpi: + session.delete(kpi) + session.commit() + LOGGER.info("Deleted KPI with kpi_id: %s", kpi_id_to_delete) + else: + LOGGER.warning("KPI with kpi_id %s not found", kpi_id_to_delete) + except SQLAlchemyError as e: + session.rollback() + LOGGER.error("Error deleting KPI with kpi_id %s: %s", kpi_id_to_delete, e) + finally: + session.close() + + def delete_collector(self, request: CollectorId): + session = self.Session() + try: + collector_id_to_delete = request.collector_id.uuid + collector = session.query(CollectorModel).filter_by(collector_id=collector_id_to_delete).first() + if collector: + session.delete(collector) + session.commit() + LOGGER.info("Deleted KPI with kpi_id: %s", collector_id_to_delete) + else: + LOGGER.warning("KPI with kpi_id %s not found", collector_id_to_delete) + except SQLAlchemyError as e: + session.rollback() + LOGGER.error("Error deleting KPI with kpi_id %s: %s", collector_id_to_delete, e) finally: session.close() \ No newline at end of file diff --git a/src/telemetry/database/tests/messages.py b/src/telemetry/database/tests/messages.py index ea59d09251934ea0785d5367afea4919c8d05979..258d4a844324b15aec4796f6d06c600f46a127cf 100644 --- a/src/telemetry/database/tests/messages.py +++ b/src/telemetry/database/tests/messages.py @@ -46,9 +46,21 @@ def create_kpi_id_request(): _create_kpi_id_request.kpi_id.uuid = '11e2c6c6-b507-40aa-ab3a-ffd41e7125f0' return _create_kpi_id_request +def create_collector_id_request(): + _create_collector_id_request = telemetry_frontend_pb2.CollectorId() + _create_collector_id_request.collector_id.uuid = '50ba9199-7e9d-45b5-a2fc-3f97917bad65' + return _create_collector_id_request + def create_kpi_filter_request(): # create a dict as follows: 'Key' = 'KpiModel' column name and 'Value' = filter to apply. _create_kpi_filter_request = dict() _create_kpi_filter_request['kpi_sample_type'] = 102 _create_kpi_filter_request['kpi_id'] = '11e2c6c6-b507-40aa-ab3a-ffd41e7125f0' + return _create_kpi_filter_request + +def create_collector_filter_request(): + # create a dict as follows: 'Key' = 'KpiModel' column name and 'Value' = filter to apply. + _create_kpi_filter_request = dict() + _create_kpi_filter_request['sampling_interval_s'] = 3.0 + # _create_kpi_filter_request['kpi_id'] = '11e2c6c6-b507-40aa-ab3a-ffd41e7125f0' return _create_kpi_filter_request \ No newline at end of file diff --git a/src/telemetry/database/tests/telemetryDBtests.py b/src/telemetry/database/tests/telemetryDBtests.py index 217bdcfd484fcea2ae80ad45997799e44fac4fdc..81431beb758d6651527f8a7d9088c73524bfdc48 100644 --- a/src/telemetry/database/tests/telemetryDBtests.py +++ b/src/telemetry/database/tests/telemetryDBtests.py @@ -19,7 +19,8 @@ from telemetry.database.TelemetryDBmanager import TelemetryDBmanager from telemetry.database.TelemetryEngine import TelemetryEngine from telemetry.database.tests import temp_DB from .messages import create_kpi_request, create_collector_request, \ - create_kpi_id_request, create_kpi_filter_request + create_kpi_id_request, create_kpi_filter_request, \ + create_collector_id_request, create_collector_filter_request logging.basicConfig(level=logging.INFO) LOGGER = logging.getLogger(__name__) @@ -29,22 +30,45 @@ LOGGER = logging.getLogger(__name__) def test_telemetry_object_creation(): LOGGER.info('--- test_telemetry_object_creation: START') + LOGGER.info('>>> Creating TelemetryDBmanager Object: ') TelemetryDBmanagerObj = TelemetryDBmanager() + # LOGGER.info('>>> Creating Tables: ') # TelemetryDBmanagerObj.create_tables() + # LOGGER.info('>>> Verifing Table creation: ') # TelemetryDBmanagerObj.verify_tables() - LOGGER.info('>>> Row Insertion Operation: kpi Table') + + LOGGER.info('>>> TESTING: Row Insertion Operation: kpi Table') kpi_obj = create_kpi_request() TelemetryDBmanagerObj.inser_kpi(kpi_obj) - LOGGER.info('>>> Row Insertion Operation: collector Table') + + LOGGER.info('>>> TESTING: Row Insertion Operation: collector Table') collector_obj = create_collector_request() TelemetryDBmanagerObj.insert_collector(collector_obj) - LOGGER.info('>>> Get KpiDescriptor ') + + LOGGER.info('>>> TESTING: Get KpiDescriptor ') kpi_id_obj = create_kpi_id_request() TelemetryDBmanagerObj.get_kpi_descriptor(kpi_id_obj) + + LOGGER.info('>>> TESTING: Select Collector ') + collector_id_obj = create_collector_id_request() + TelemetryDBmanagerObj.get_collector(collector_id_obj) + + LOGGER.info('>>> TESTING: Applying kpi filter ') kpi_filter : dict[str, Any] = create_kpi_filter_request() TelemetryDBmanagerObj.select_kpi_descriptor(**kpi_filter) + LOGGER.info('>>> TESTING: Applying collector filter ') + collector_filter : dict[str, Any] = create_collector_filter_request() + TelemetryDBmanagerObj.select_collector(**collector_filter) + + LOGGER.info('>>> TESTING: Delete KpiDescriptor ') + kpi_id_obj = create_kpi_id_request() + TelemetryDBmanagerObj.delete_kpi_descriptor(kpi_id_obj) + + LOGGER.info('>>> TESTING: Delete Collector ') + collector_id_obj = create_collector_id_request() + TelemetryDBmanagerObj.delete_collector(collector_id_obj) \ No newline at end of file diff --git a/src/telemetry/database/tests/temp_DB.py b/src/telemetry/database/tests/temp_DB.py index 5d3c3b1bdd253df44b714e6246048f0badd45b4a..7c1074fcff663e61be0a186d34751cdadf3bb66d 100644 --- a/src/telemetry/database/tests/temp_DB.py +++ b/src/telemetry/database/tests/temp_DB.py @@ -204,7 +204,42 @@ class DatabaseManager: finally: session.close() LOGGER.info("get_filtered_collector_rows method execution finished.") - + + def delete_kpi_by_id(self, kpi_id): + session = self.Session() + try: + kpi = session.query(Kpi).filter_by(kpi_id=kpi_id).first() + if kpi: + session.delete(kpi) + session.commit() + LOGGER.info("Deleted KPI with kpi_id: %s", kpi_id) + else: + LOGGER.warning("KPI with kpi_id %s not found", kpi_id) + except SQLAlchemyError as e: + session.rollback() + LOGGER.error("Error deleting KPI with kpi_id %s: %s", kpi_id, e) + finally: + session.close() + LOGGER.info("delete_kpi_by_id method execution finished.") + + def delete_collector_by_id(self, collector_id): + session = self.Session() + try: + collector = session.query(Collector).filter_by(collector_id=collector_id).first() + if collector: + session.delete(collector) + session.commit() + LOGGER.info("Deleted Collector with collector_id: %s", collector_id) + else: + LOGGER.warning("Collector with collector_id %s not found", collector_id) + except SQLAlchemyError as e: + session.rollback() + LOGGER.error("Error deleting Collector with collector_id %s: %s", collector_id, e) + finally: + session.close() + LOGGER.info("delete_collector_by_id method execution finished.") + + # Example Usage def main(): CRDB_SQL_PORT = "26257" @@ -281,4 +316,12 @@ def main(): # Get filtered rows from Collector table filtered_collector_rows = db_manager.get_filtered_collector_rows(collector='Collector 1') - LOGGER.info("Filtered Collector Rows: %s", filtered_collector_rows) \ No newline at end of file + LOGGER.info("Filtered Collector Rows: %s", filtered_collector_rows) + + # Delete a KPI by kpi_id + kpi_id_to_delete = '123e4567-e89b-12d3-a456-426614174000' + db_manager.delete_kpi_by_id(kpi_id_to_delete) + + # Delete a Collector by collector_id + collector_id_to_delete = '123e4567-e89b-12d3-a456-426614174001' + db_manager.delete_collector_by_id(collector_id_to_delete)