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)
