def delete_object(self, public_id: int, user: UserModel, permission: AccessControlPermission = None): type_id = self.get_object(public_id=public_id).type_id type_ = self._type_manager.get(type_id) if not type_.active: raise AccessDeniedError( f'Objects cannot be removed because type `{type_.name}` is deactivated.' ) verify_access(type_, user, permission) try: if self._event_queue: event = Event( "cmdb.core.object.deleted", { "id": public_id, "type_id": self.get_object(public_id).get_type_id(), "user_id": user.get_public_id(), "event": 'delete' }) self._event_queue.put(event) ack = self._delete(CmdbObject.COLLECTION, public_id) return ack except (CMDBError, Exception): raise ObjectDeleteError(msg=public_id)
def run_job_manual(self, public_id: int, request_user: UserModel) -> bool: if self._event_queue: event = Event("cmdb.exportd.run_manual", {"id": public_id, "user_id": request_user.get_public_id(), "event": 'manuel'}) self._event_queue.put(event) return True
def insert_template(self, data: (DocapiTemplate, dict)) -> int: """ Insert new DocapiTemplate Object Args: data: init data Returns: Public ID of the new DocapiTemplate in database """ if isinstance(data, dict): try: new_object = DocapiTemplate(**data) except CMDBError as e: raise DocapiTemplateManagerInsertError(e) elif isinstance(data, DocapiTemplate): new_object = data try: ack = self.dbm.insert(collection=DocapiTemplate.COLLECTION, data=new_object.to_database()) if self._event_queue: event = Event( "cmdb.docapi.added", { "id": new_object.get_public_id(), "active": new_object.get_active(), "user_id": new_object.get_author_id() }) self._event_queue.put(event) except CMDBError as e: raise DocapiTemplateManagerInsertError(e) return ack
def worker(job: ExportdJob, request_user: UserModel): from flask import make_response as make_res from cmdb.exportd.exporter_base import ExportdManagerBase from cmdb.event_management.event import Event try: event = Event( "cmdb.exportd.run_manual", { "id": job.get_public_id(), "user_id": request_user.get_public_id(), "event": 'manuel' }) content = ExportdManagerBase(job, object_manager, log_manager, event).execute( request_user.public_id, request_user.get_display_name(), False) response = make_res(content.data, content.status) response.headers['Content-Type'] = '%s; charset=%s' % ( content.mimetype, content.charset) return response except Exception as err: LOGGER.error(err) return abort(404)
def update_job(self, data: (dict, ExportdJob), request_user: User, event_start=True) -> str: """ Update new ExportdJob Object Args: data: init data request_user: current user, to detect who triggered event event_start: Controls whether an event should be started Returns: Public ID of the ExportdJob in database """ if isinstance(data, dict): update_object = ExportdJob(**data) elif isinstance(data, ExportdJob): update_object = data else: raise ExportdJobManagerUpdateError(f'Could not update job with ID: {data.get_public_id()}') update_object.last_execute_date = datetime.utcnow() ack = self._update( collection=ExportdJob.COLLECTION, public_id=update_object.get_public_id(), data=update_object.to_database() ) if self._event_queue and event_start: event = Event("cmdb.exportd.updated", {"id": update_object.get_public_id(), "active": update_object.scheduling["event"]["active"] and update_object.get_active(), "user_id": request_user.get_public_id()}) self._event_queue.put(event) return ack.acknowledged
def insert_job(self, data: (ExportdJob, dict)) -> int: """ Insert new ExportdJob Object Args: data: init data Returns: Public ID of the new ExportdJob in database """ if isinstance(data, dict): try: new_object = ExportdJob(**data) except CMDBError as e: raise ExportdJobManagerInsertError(e) elif isinstance(data, ExportdJob): new_object = data try: ack = self.dbm.insert( collection=ExportdJob.COLLECTION, data=new_object.to_database() ) if self._event_queue: event = Event("cmdb.exportd.added", {"id": new_object.get_public_id(), "active": new_object.scheduling["event"]["active"] and new_object.get_active(), "user_id": new_object.get_author_id()}) self._event_queue.put(event) except CMDBError as e: raise ExportdJobManagerInsertError(e) return ack
def update_object(self, data: (dict, CmdbObject), user: UserModel = None, permission: AccessControlPermission = None) -> str: if isinstance(data, dict): update_object = CmdbObject(**data) elif isinstance(data, CmdbObject): update_object = data else: raise ObjectManagerUpdateError( 'Wrong CmdbObject init format - expecting CmdbObject or dict') update_object.last_edit_time = datetime.utcnow() if user: update_object.editor_id = user.public_id type_ = self._type_manager.get(update_object.type_id) verify_access(type_, user, permission) ack = self._update(collection=CmdbObject.COLLECTION, public_id=update_object.get_public_id(), data=update_object.__dict__) # create cmdb.core.object.updated event if self._event_queue and user: event = Event( "cmdb.core.object.updated", { "id": update_object.get_public_id(), "type_id": update_object.get_type_id(), "user_id": user.get_public_id() }) self._event_queue.put(event) return ack.acknowledged
def insert_object(self, data: (CmdbObject, dict)) -> int: """ Insert new CMDB Object Args: data: init data request_user: current user, to detect who triggered event Returns: Public ID of the new object in database """ if isinstance(data, dict): try: new_object = CmdbObject(**data) except CMDBError as e: LOGGER.debug( f'Error while inserting object - error: {e.message}') raise ObjectManagerInsertError(e) elif isinstance(data, CmdbObject): new_object = data try: ack = self.dbm.insert(collection=CmdbObject.COLLECTION, data=new_object.to_database()) if self._event_queue: event = Event( "cmdb.core.object.added", { "id": new_object.get_public_id(), "type_id": new_object.get_type_id(), "user_id": new_object.author_id }) self._event_queue.put(event) except (CMDBError, PublicIDAlreadyExists) as e: raise ObjectInsertError(e) return ack
def update_template(self, data: (dict, DocapiTemplate), request_user: UserModel) -> str: """ Update new DocapiTemplat Object Args: data: init data request_user: current user, to detect who triggered event Returns: Public ID of the DocapiTemplate in database """ if isinstance(data, dict): update_object = DocapiTemplate(**data) elif isinstance(data, DocapiTemplate): update_object = data else: raise DocapiTemplateManagerUpdateError( f'Could not update template with ID: {data.get_public_id()}') update_object.last_execute_date = datetime.utcnow() ack = self._update(collection=DocapiTemplate.COLLECTION, public_id=update_object.get_public_id(), data=update_object.to_database()) if self._event_queue: event = Event( "cmdb.docapi.updated", { "id": update_object.get_public_id(), "active": update_object.get_active(), "user_id": request_user.get_public_id() }) self._event_queue.put(event) return ack.acknowledged
def delete_many_objects(self, filter_query: dict, public_ids, user: UserModel): ack = self._delete_many(CmdbObject.COLLECTION, filter_query) if self._event_queue: event = Event("cmdb.core.objects.deleted", {"ids": public_ids, "user_id": user.get_public_id(), "event": 'delete'}) self._event_queue.put(event) return ack
def start_thread(event: Event): event_type = event.get_type() # start new threads if "cmdb.exportd.run_manual" == event_type: new_thread = ExportdThread(event=event, state=True) new_thread.start() elif "cmdb.core.object" in event_type: new_thread = ExportdThread(event=event, state=False) new_thread.start() elif "cmdb.exportd" in event_type: new_thread = ExportdThread(event=event, state=event.get_param("active") in ['true', True]) new_thread.start()
def delete_template(self, public_id: int, request_user: UserModel) -> bool: try: ack = self._delete(collection=DocapiTemplate.COLLECTION, public_id=public_id) if self._event_queue: event = Event("cmdb.docapi.deleted", {"id": public_id, "active": False, "user_id": request_user.get_public_id()}) self._event_queue.put(event) return ack except Exception: raise DocapiTemplateManagerDeleteError(f'Could not delete template with ID: {public_id}')
def delete_job(self, public_id: int, request_user: User) -> bool: try: ack = self._delete(collection=ExportdJob.COLLECTION, public_id=public_id) if self._event_queue: event = Event("cmdb.exportd.deleted", {"id": public_id, "active": False, "user_id": request_user.get_public_id()}) self._event_queue.put(event) return ack except Exception: raise ExportdJobManagerDeleteError(f'Could not delete job with ID: {public_id}')
def __init__(self, event: Event, state: bool = False): scr = SystemConfigReader() database_options = scr.get_all_values_from_section('Database') database = DatabaseManagerMongo(**database_options) super(ExportdThread, self).__init__() self.job = None self.job_id = int(event.get_param("id")) self.type_id = int( event.get_param("type_id")) if event.get_param("type_id") else None self.user_id = int(event.get_param("user_id")) self.event = event self.is_active = state self.exception_handling = None self.object_manager = CmdbObjectManager(database_manager=database) self.log_manager = ExportdLogManager(database_manager=database) self.exportd_job_manager = ExportdJobManagement( database_manager=database) self.user_manager = UserManager(database_manager=database)
def insert_type(self, data: dict): try: ack = self._insert(collection=TypeModel.COLLECTION, data=data) LOGGER.debug(f"Inserted new type with ack {ack}") if self._event_queue: event = Event("cmdb.core.objecttype.added", {"id": ack}) self._event_queue.put(event) except PublicIDAlreadyExists as err: raise TypeAlreadyExists(type_id=str(err)) except (CMDBError, InsertError) as err: raise TypeInsertError(str(err)) return ack
def worker(job: ExportdJob, request_user: User): from flask import make_response as make_res from cmdb.exportd.exporter_base import ExportdManagerBase from cmdb.event_management.event import Event try: event = Event("cmdb.exportd.pull") content = ExportdManagerBase(job).execute(event, request_user.public_id, request_user.get_name(), False) response = make_res(content.data, content.status) response.headers['Content-Type'] = '%s; charset=%s' % (content.mimetype, content.charset) return response except Exception as err: LOGGER.error(err) return abort(404)
def delete_object(self, public_id: int, request_user: User): try: if self._event_queue: event = Event( "cmdb.core.object.deleted", { "id": public_id, "type_id": self.get_object(public_id).get_type_id(), "user_id": request_user.get_public_id() }) self._event_queue.put(event) ack = self._delete(CmdbObject.COLLECTION, public_id) return ack except (CMDBError, Exception): raise ObjectDeleteError(msg=public_id)
def handler(self, event: Event): # get type of Event event_type = event.get_type() # get public_id from Event event_param_id = event.get_param("id") # Remove duplicate entries in the Queue of upcoming events for q in scheduler.queue: arg = q.argument[0] if "cmdb.core.object" in event_type and event_param_id == arg.get_param( "id"): scheduler.cancel(q) elif "cmdb.exportd" in event_type and event_param_id == arg.get_param( "id"): scheduler.cancel(q) if event.get_param("active"): scheduler.enter(10, 1, self.start_thread, argument=(event, )) elif "cmdb.exportd.deleted" != event_type: scheduler.enter(5, 1, self.start_thread, argument=(event, ))
def __process_event_cb(self, ch, method, properties, body): """event processing this callback function is executed, if an event was reveived. Args: ch: AMQP channel method: AMQP method properties: AMQP properties body: AMQP message body """ event = Event.create_event(body) # allow None values, if event receiving should be ignored if self.__receiver_callback: self.__receiver_callback(event)
def insert_object(self, data: (CmdbObject, dict), user: UserModel = None, permission: AccessControlPermission = None) -> int: """ Insert new CMDB Object Args: data: init data user: current user, to detect who triggered event permission: extended user acl rights Returns: Public ID of the new object in database """ new_object = None if isinstance(data, dict): try: new_object = CmdbObject(**data) except CMDBError as e: LOGGER.debug( f'Error while inserting object - error: {e.message}') raise ObjectManagerInsertError(e) elif isinstance(data, CmdbObject): new_object = data type_ = self._type_manager.get(new_object.type_id) if not type_.active: raise AccessDeniedError( f'Objects cannot be created because type `{type_.name}` is deactivated.' ) verify_access(type_, user, permission) try: ack = self.dbm.insert(collection=CmdbObject.COLLECTION, data=new_object.__dict__) if self._event_queue: event = Event( "cmdb.core.object.added", { "id": new_object.get_public_id(), "type_id": new_object.get_type_id(), "user_id": new_object.author_id, "event": 'insert' }) self._event_queue.put(event) except (CMDBError, PublicIDAlreadyExists) as e: raise ObjectInsertError(e) return ack
def update_type(self, data: (CmdbType, dict)): if isinstance(data, CmdbType): update_type = data elif isinstance(data, dict): update_type = CmdbType(**data) else: raise WrongInputFormatError(CmdbType, data, "Possible data: dict or CmdbType") ack = self._update(collection=CmdbType.COLLECTION, public_id=update_type.get_public_id(), data=update_type.to_database()) if self._event_queue: event = Event("cmdb.core.objecttype.updated", {"id": update_type.get_public_id()}) self._event_queue.put(event) return ack
def update_type(self, data: (TypeModel, dict)): if isinstance(data, TypeModel): update_type = data elif isinstance(data, dict): update_type = TypeModel.from_data(data) else: raise WrongInputFormatError(TypeModel, data, "Possible data: dict or TypeModel") ack = self._update(collection=TypeModel.COLLECTION, public_id=update_type.get_public_id(), data=TypeModel.to_json(update_type)) if self._event_queue: event = Event("cmdb.core.objecttype.updated", {"id": update_type.get_public_id()}) self._event_queue.put(event) return ack
def delete_object(self, public_id: int, user: UserModel, permission: AccessControlPermission = None): type_id = self.get_object(public_id=public_id).type_id type_ = self._type_manager.get(type_id) verify_access(type_, user, permission) try: if self._event_queue: event = Event( "cmdb.core.object.deleted", { "id": public_id, "type_id": self.get_object(public_id).get_type_id(), "user_id": user.get_public_id() }) self._event_queue.put(event) ack = self._delete(CmdbObject.COLLECTION, public_id) return ack except (CMDBError, Exception): raise ObjectDeleteError(msg=public_id)
def insert_type(self, data: (CmdbType, dict)): if isinstance(data, CmdbType): new_type = data elif isinstance(data, dict): new_type = CmdbType(**data) else: raise WrongInputFormatError(CmdbType, data, "Possible data: dict or CmdbType") try: ack = self._insert(collection=CmdbType.COLLECTION, data=new_type.to_database()) LOGGER.debug(f"Inserted new type with ack {ack}") if self._event_queue: event = Event("cmdb.core.objecttype.added", {"id": new_type.get_public_id()}) self._event_queue.put(event) except PublicIDAlreadyExists: raise TypeAlreadyExists(type_id=new_type.get_public_id()) except (CMDBError, InsertError): raise TypeInsertError(new_type.get_public_id()) return ack
def update_object(self, data: (dict, CmdbObject), request_user: User) -> str: if isinstance(data, dict): update_object = CmdbObject(**data) elif isinstance(data, CmdbObject): update_object = data else: raise ObjectManagerUpdateError( 'Wrong CmdbObject init format - expecting CmdbObject or dict') update_object.last_edit_time = datetime.utcnow() ack = self._update(collection=CmdbObject.COLLECTION, public_id=update_object.get_public_id(), data=update_object.to_database()) # create cmdb.core.object.updated event if self._event_queue and request_user: event = Event( "cmdb.core.object.updated", { "id": update_object.get_public_id(), "type_id": update_object.get_type_id(), "user_id": request_user.get_public_id() }) self._event_queue.put(event) return ack.acknowledged
def delete_type(self, public_id: int): """Delete a type by the public id Also removes the id from the category type list if existing """ try: ack = self._delete(TypeModel.COLLECTION, public_id) except Exception as err: raise ObjectManagerDeleteError(err=err) if ack: try: category = self.get_category_by(types=public_id) category.types.remove(public_id) self.update_category(category=category) # If no category with this ID except ObjectManagerGetError: pass except ObjectManagerUpdateError as err: LOGGER.error(err.message) if self._event_queue: event = Event("cmdb.core.objecttype.deleted", {"id": public_id}) self._event_queue.put(event) return ack
def update_object(self, data: (dict, CmdbObject), user: UserModel = None, permission: AccessControlPermission = None) -> str: if isinstance(data, dict): update_object = CmdbObject(**data) elif isinstance(data, CmdbObject): update_object = data else: raise ObjectManagerUpdateError( 'Wrong CmdbObject init format - expecting CmdbObject or dict') update_object.last_edit_time = datetime.now(timezone.utc) if user: update_object.editor_id = user.public_id type_ = self._type_manager.get(update_object.type_id) if not type_.active: raise AccessDeniedError( f'Objects cannot be updated because type `{type_.name}` is deactivated.' ) verify_access(type_, user, permission) ack = self._update(collection=CmdbObject.COLLECTION, public_id=update_object.get_public_id(), data=update_object.__dict__) if self._event_queue and user: event = Event( "cmdb.core.object.updated", { "id": update_object.get_public_id(), "type_id": update_object.get_type_id(), "user_id": user.get_public_id(), 'event': 'update' }) self._event_queue.put(event) return ack.acknowledged
def delete_many_types(self, filter_query: dict, public_ids): ack = self._delete_many(CmdbType.COLLECTION, filter_query) if self._event_queue: event = Event("cmdb.core.objecttypes.deleted", {"ids": public_ids}) self._event_queue.put(event) return ack
def delete_type(self, public_id: int): ack = self._delete(CmdbType.COLLECTION, public_id) if self._event_queue: event = Event("cmdb.core.objecttype.deleted", {"id": public_id}) self._event_queue.put(event) return ack
def _handle_event(self, event: Event): LOGGER.debug("event received: {}".format(event.get_type())) self.handler(event)