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 get_exportd_jobs(params: CollectionParameters):
"""Iterate route for exportd jobs"""
job_manager = ExportDJobManager(current_app.database_manager)
body = request.method == 'HEAD'
try:
iteration_result: IterationResult[ExportdJob] = job_manager.iterate(
filter=params.filter,
limit=params.limit,
skip=params.skip,
sort=params.sort,
order=params.order)
types = [ExportdJob.to_json(type) for type in iteration_result.results]
api_response = GetMultiResponse(types,
total=iteration_result.total,
params=params,
url=request.url,
model=ExportdJob.MODEL,
body=body)
except ManagerIterationError as err:
return abort(400, err.message)
except ManagerGetError as err:
return abort(404, err.message)
return api_response.make_response()
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 get_job(self, public_id: int) -> ExportdJob:
try:
result = self.dbm.find_one(collection=ExportdJob.COLLECTION, public_id=public_id)
except (ExportdJobManagerGetError, Exception) as err:
LOGGER.error(err)
raise err
return ExportdJob(**result)
def get_all_jobs(self):
job_list = []
for founded_job in self.dbm.find_all(collection=ExportdJob.COLLECTION):
try:
job_list.append(ExportdJob(**founded_job))
except CMDBError:
continue
return job_list
def update_job(self, data: (dict, ExportdJob), request_user: UserModel, 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.now(timezone.utc)
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:
state = update_object.scheduling["event"]["active"] and update_object.get_active()
event = Event("cmdb.exportd.updated", {"id": update_object.get_public_id(),
"active": state,
"user_id": request_user.get_public_id(),
"event": 'automatic'})
self._event_queue.put(event)
return ack.acknowledged
def get_job_by_event_based(self, state):
formatted_filter = {'scheduling.event.active': state}
job_list = []
for founded_job in self.dbm.find_all(collection=ExportdJob.COLLECTION, filter=formatted_filter):
try:
job_list.append(ExportdJob(**founded_job))
except CMDBError:
continue
return job_list
def get_job_by_args(self, **requirements) -> ExportdJob:
try:
found_type_list = self._get_many(collection=ExportdJob.COLLECTION, limit=1, **requirements)
if len(found_type_list) > 0:
return ExportdJob(**found_type_list[0])
else:
raise ObjectManagerGetError(err='More than 1 type matches this requirement')
except (CMDBError, Exception) as e:
raise ObjectManagerGetError(err=e)
def add_job(request_user: UserModel):
from bson import json_util
add_data_dump = json.dumps(request.json)
try:
new_job_data = json.loads(add_data_dump,
object_hook=json_util.object_hook)
new_job_data['public_id'] = exportd_manager.get_new_id(
ExportdJob.COLLECTION)
new_job_data['last_execute_date'] = datetime.utcnow()
new_job_data['author_id'] = request_user.get_public_id()
new_job_data['author_name'] = request_user.get_display_name()
new_job_data['state'] = ExecuteState.SUCCESSFUL.name
except TypeError as e:
LOGGER.warning(e)
abort(400)
try:
job_instance = ExportdJob(**new_job_data)
except CMDBError as e:
LOGGER.debug(e)
return abort(400)
try:
ack = exportd_manager.insert_job(job_instance)
except ExportdJobManagerInsertError:
return abort(500)
# Generate new insert log
try:
log_params = {
'job_id': job_instance.get_public_id(),
'state': True,
'user_id': request_user.get_public_id(),
'user_name': request_user.get_display_name(),
'event': LogAction.CREATE.name,
'message': '',
}
log_manager.insert_log(action=LogAction.CREATE,
log_type=ExportdJobLog.__name__,
**log_params)
except LogManagerInsertError as err:
LOGGER.error(err)
resp = make_response(ack)
return resp
def update_job(request_user: UserModel):
from bson import json_util
add_data_dump = json.dumps(request.json)
new_job_data = None
try:
new_job_data = json.loads(add_data_dump,
object_hook=json_util.object_hook)
except TypeError as e:
LOGGER.warning(e)
abort(400)
try:
state = new_job_data["state"]
update_job_instance = ExportdJob(**new_job_data)
except CMDBError:
return abort(400)
try:
exportd_manager.update_job(update_job_instance, request_user, False)
except ExportdJobManagerUpdateError:
return abort(500)
# Generate new insert log
if state not in ExecuteState.RUNNING.name:
try:
log_params = {
'job_id': update_job_instance.get_public_id(),
'state': True,
'user_id': request_user.get_public_id(),
'user_name': request_user.get_display_name(),
'event': LogAction.EDIT.name,
'message': '',
}
log_manager.insert_log(action=LogAction.EDIT,
log_type=ExportdJobLog.__name__,
**log_params)
except LogManagerInsertError as err:
LOGGER.error(err)
resp = make_response(update_job_instance)
return resp
