async def get_unsupported_features(self, component_name="", feature_name=""): """ Get Unsupported Features in Following Formats: 1) No Component Name : Return All Features List. 2) No Feature Name : Return All the Features Related to Components Provided. :param component_name: Name of Component :type: String :param feature_name: Name of Feature :type: String :return: List of Features Found. """ query = Query() # Generate Key if component_name: query.filter_by( Compare(UnsupportedFeaturesModel.component_name, "=", component_name)) if feature_name: query.filter_by( And( Compare(UnsupportedFeaturesModel.feature_name, "=", feature_name))) feature_details = await self.storage(UnsupportedFeaturesModel).get( query) if not feature_details: return [] return [ each_feature.to_primitive() for each_feature in feature_details ]
async def delete(self, name: str) -> None: """Removes the data from the encrypted storage.""" neb = await self._get_item(name) if neb is None: raise KeyError(f'Item "{name}" was not found in secure storage') await self._storage(NamedEncryptedBytes).delete( Compare(NamedEncryptedBytes.name, '=', name))
async def get_by_id(self, obj_id: Any) -> Union[BaseModel, None]: """ Simple implementation of get function. Important note: in terms of this API 'id' means BaseModel.primary_key reference. If model contains 'id' field please use ordinary get call. For example, await db(YourBaseModel).get(Query().filter_by(Compare(YourBaseModel.id, "=", obj_id))) This API call is equivalent to await db(YourBaseModel).get(Query().filter_by( Compare(YourBaseModel.primary_key, "=", obj_id))) :param Any obj_id: :return: BaseModel if object was found by its id and None otherwise """ id_field = getattr(self._model, self._model.primary_key) try: converted = id_field.to_native(obj_id) except ConversionError as e: raise DataAccessInternalError(f"{e}") query = Query().filter_by( Compare(self._model.primary_key, "=", converted)) result = await self.get(query) if result: return result.pop() return None
async def retrieve_all(self, bundle_id) -> [SupportBundleModel]: if bundle_id: query = Query().limit(SupportBundleModel.max_count).filter_by(\ Compare(SupportBundleModel.bundle_id, \ '=', bundle_id)) else: query = Query().limit(SupportBundleModel.max_count) return await self.db(SupportBundleModel).get(query)
async def _get_item(self, name: str) -> NamedEncryptedBytes: """ Gets NamedEncryptedBytes object with encrypted payload from the storage. Returns NamedEncryptedBytes object if the item with provided name exists or None """ query = Query().filter_by(Compare(NamedEncryptedBytes.name, '=', name)) neb = next(iter(await self._storage(NamedEncryptedBytes).get(query)), None) return neb
async def is_feature_supported(self, component_name, feature_name): """ Check whether the feature supported or not. :param component_name: Name of Component :type: String :param feature_name: Name of Feature :type: String :return: Supported -> True/Not-Supported -> False """ feature_id = UnsupportedFeaturesModel.create_feature_id( *(component_name, const.UNSUPPORTED_FEATURE, feature_name)) # Create Query query = Query().filter_by( Compare(UnsupportedFeaturesModel.feature_id, '=', feature_id)) feature = await self.storage(UnsupportedFeaturesModel).get(query) if feature: return False return True
async def delete_event(self, entity, entity_id, component, component_id): """ Delete all Component Related Events. :param entity: Entity Name :type: Str :param entity_id: Entity Id :type: Str :param component: Component Name :type: Str :param component_id: Component Id :type: Str :return: """ # Generate Key decision_id = DecisionModel.create_decision_id(entity, entity_id, component, component_id) Log.debug(f"Deleting event for {decision_id}") # Delete all the Decisions Related to The Event. await self.storage(DecisionModel).delete( Compare(DecisionModel.decision_id, 'like', decision_id))
async def delete_by_id(self, obj_id: Any) -> bool: """ Delete base model by its id. :param Any obj_id: id of the object to be deleted :return: BaseModel if object was found by its id and None otherwise :return: `True` if object was deleted successfully and `False` otherwise """ # Generic implementation of delete by id functionality id_field = getattr(self._model, self._model.primary_key) try: converted = id_field.to_native(obj_id) except ConversionError as e: raise DataAccessInternalError(f"{e}") filter_condition = Compare(self._model.primary_key, "=", converted) result = await self.delete(filter_condition) return result > 0
async def get_event(self, entity, entity_id, component, component_id, alert_time): """ Get a event with specific time. :param entity: Entity Name :type: Str :param entity_id: Entity Id :type: Str :param component: Component Name :type: Str :param component_id: Component Id :type: Str :param alert_time: Alert Generated time :type: Str :return: action For Respective Alert :type: Str """ # Generate Key decision_id = DecisionModel.create_decision_id(entity, entity_id, component, component_id, alert_time) Log.debug(f"Fetch event for {decision_id}") # Create Query query = Query().filter_by( Compare(DecisionModel.decision_id, '=', decision_id)) return await self.storage(DecisionModel).get(query)
async def update_by_id(self, obj_id: Any, to_update: dict) -> bool: """ Update base model in db by id (primary key). :param Any obj_id: id-value of the object which should be updated (primary key value) :param dict to_update: dictionary with fields and values which should be updated :return: `True` if object was updated and `False` otherwise """ # Generic code for update_by_id method of particular method id_field = getattr(self._model, self._model.primary_key) try: converted = id_field.to_native(obj_id) except ConversionError as e: raise DataAccessInternalError(f"{e}") model_filter = Compare(self._model.primary_key, "=", converted) result = await self.update(model_filter, to_update) return result > 0
async def get_event_time(self, entity, entity_id, component, component_id, **kwargs): """ Fetch All Event with All Components Name. :param entity: Entity Name :type: Str :param entity_id: Entity Id :type: Str :param component: Component Name :type: Str :param component_id: Component Id :type: Str :return: """ # Generate Key decision_id = DecisionModel.create_decision_id(entity, entity_id, component, component_id) Log.debug(f"Fetch event time for {decision_id}") # Create Query query = Query().filter_by( Compare(DecisionModel.decision_id, 'like', decision_id)) if kwargs.get("sort_by"): query.order_by(kwargs["sort_by"].field, kwargs['sort_by'].order) return await self.storage(DecisionModel).get(query)
async def example(): conf = GeneralConfig({ "databases": { "es_db": { "import_path": "ElasticSearchDB", "config": { "hosts": ["localhost"], "port": 9200, "login": "", "password": "" } }, "consul_db": { "import_path": "ConsulDB", "config": { "hosts": ["127.0.0.1"], "port": 8500, # HTTP API Port "login": "", "password": "" } } }, "models": [ { "import_path": "cortx.utils.data.db.examples.consul_storage.AlertModel", "database": "consul_db", "config": { "es_db": { "collection": "alerts" }, "consul_db": { "collection": "alerts" } } }, ] }) db = DataBaseProvider(conf) alert1 = AlertModel(ALERT1) alert2 = AlertModel(ALERT2) alert3 = AlertModel(ALERT3) alert4 = AlertModel(ALERT4) await db(AlertModel).store(alert1) await db(AlertModel).store(alert2) await db(AlertModel).store(alert3) await db(AlertModel).store(alert4) limit = 1 offset = 0 for _ in range(4): res = await db(AlertModel).get(Query().offset(offset).limit(limit)) for model in res: print( f"Get by offset = {offset}, limit = {limit} : {model.to_primitive()}" ) offset += 1 res = await db(AlertModel)._get_all_raw() print([model for model in res]) _id = 2 res = await db(AlertModel).get_by_id(_id) if res is not None: print(f"Get by id = {_id}: {res.to_primitive()}") to_update = {'state': "Good", 'location': "USA"} await db(AlertModel).update_by_id(_id, to_update) res = await db(AlertModel).get_by_id(_id) if res is not None: print(f"Get by id after update = {_id}: {res.to_primitive()}") filter_obj = Or( Compare(AlertModel.status, "=", "Success"), And(Compare(AlertModel.alert_uuid, "<=", 3), Compare(AlertModel.status, "=", "Success"))) query = Query().filter_by(filter_obj) res = await db(AlertModel).get(query) for model in res: print(f"Get by query ={model.to_primitive()}") await db(AlertModel).update(filter_obj, to_update) res = await db(AlertModel).get(query) for model in res: print(f"Get by query after update={model.to_primitive()}") query = Query().filter_by(filter_obj).order_by(AlertModel.location) res = await db(AlertModel).get(query) for model in res: print(f"Get by query with order_by ={model.to_primitive()}") count = await db(AlertModel).count(filter_obj) print(f"Count by filter = {count}") num = await db(AlertModel).delete(filter_obj) print(f"Deleted by filter={num}") _id = 2 is_deleted = await db(AlertModel).delete_by_id(_id) print(f"Object by id = {_id} was deleted: {is_deleted}") count = await db(AlertModel).count() print(f"Remaining objects in consul = {count}")
async def example(): conf = GeneralConfig({ "databases": { "es_db": { "import_path": "ElasticSearchDB", "config": { "hosts": ["localhost"], "port": 9200, "login": "", "password": "" } } }, "models": [ { "import_path": "cortx.utils.data.db.examples.elasticsearch_storage.AlertModel", "database": "es_db", "config": { "es_db": { "collection": "alert" } } }] }) db = DataBaseProvider(conf) alert1 = AlertModel(ALERT1) alert2 = AlertModel(ALERT2) alert3 = AlertModel(ALERT3) alert4 = AlertModel(ALERT4) await db(AlertModel).store(alert1) await db(AlertModel).store(alert2) await db(AlertModel).store(alert3) await db(AlertModel).store(alert4) res = await db(AlertModel).get( Query().filter_by(Compare(AlertModel.severity, "=", "Neutral")).order_by( AlertModel.severity, SortOrder.ASC)) if res: for i, model in enumerate(res): print(f"Model {i}: {model.to_primitive()}") filter = And(Compare(AlertModel.primary_key, "=", 1), And(Compare(AlertModel.status, "=", "Success"), Compare(AlertModel.primary_key, ">", 1))) query = Query().filter_by(filter).order_by(AlertModel.primary_key, SortOrder.DESC) res = await db(AlertModel).get(query) print(f"Get by query: {[alert.to_primitive() for alert in res]}") to_update = { 'location': "Russia", 'alert_uuid': 22, 'resolved': False, 'created_time': datetime.now() } await db(AlertModel).update(filter, to_update) res = await db(AlertModel).get(query) print(f"Get by query after update: {[alert.to_primitive() for alert in res]}") _id = 2 res = await db(AlertModel).get_by_id(_id) if res is not None: print(f"Get by id = {_id}: {res.to_primitive()}") await db(AlertModel).update_by_id(_id, to_update) updated_id = to_update['alert_uuid'] res = await db(AlertModel).get_by_id(updated_id) if res is not None: print(f"Get by id after update = {_id}: {res.to_primitive()}") filter_obj = Or(Compare(AlertModel.primary_key, "=", 1), Compare(AlertModel.primary_key, "=", 2), Compare(AlertModel.primary_key, "=", 4)) res = await db(AlertModel).count(filter_obj) print(f"Count by filter: {res}") res = await db(AlertModel).delete(filter_obj) print(f"Deleted by filter: {res}") _id = 3 is_deleted = await db(AlertModel).delete_by_id(_id) print(f"Object by id = {_id} was deleted: {is_deleted}")
async def retrieve_all(self, bundle_id) -> [SupportBundleModel]: query = Query().filter_by( Compare(SupportBundleModel.bundle_id, '=', bundle_id)) return await self.db(SupportBundleModel).get(query)