def __init__(self,
class_external_system,
destination_parms,
export_vars,
event=None):
self.__destination_parms = destination_parms
self.__export_vars = export_vars
external_system_class = load_class(class_external_system)
self.__external_system = external_system_class(
self.__destination_parms, self.__export_vars, event)
def get_external_system_variables(class_external_system):
try:
external_system_class = load_class(
"cmdb.exportd.externals.external_systems.{}".format(
class_external_system))
list_of_parameters = external_system_class.variables
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=str(e)))
except Exception as e:
return abort(400, e)
return make_response(list_of_parameters)
def export_file():
try:
_object_ids = request.args.get('ids', [])
_class = request.args.get('classname', '')
_zipping = request.args.get('zip', False) in ['true', 'True']
if _zipping:
export_type_class = load_class('cmdb.file_export.export_types.' + 'ZipExportType')()
file_export = FileExporter('object', export_type_class, _object_ids, _class)
else:
export_type_class = load_class('cmdb.file_export.export_types.' + _class)()
file_export = FileExporter('object', export_type_class, _object_ids)
except TypeNotFoundError as e:
return abort(400, e.message)
except ModuleNotFoundError as e:
return abort(400, e)
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=e.message))
return file_export.export()
def export_file_by_type_id(public_id, export_class):
try:
export_type_class = load_class('cmdb.file_export.export_types.' + export_class)
export_type = export_type_class()
file_export = FileExporter(None, export_type, public_id)
except TypeNotFoundError as e:
return abort(400, e.message)
except ModuleNotFoundError as e:
return abort(400, e)
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=e.message))
return file_export.export()
def export(self, data: List[RenderResult], *args):
"""
Export a zip file, containing the object list sorted by type in several files.
Args:
data: List of objects to be exported
args: the filetype with which the objects are stored
Returns:
zip file containing object files separated by types
"""
# check what export type is requested and intitializes a new zip file in memory
export_type = load_class(
f'cmdb.exporter.exporter_base.{args[0].get("classname", "")}')()
zipped_file = io.BytesIO()
# Build .zip file
with zipfile.ZipFile(zipped_file, "a", zipfile.ZIP_DEFLATED,
False) as f:
# Enters loop until the object list is empty
while len(data) > 0:
# Set what type the loop filters to and makes an empty list
type_id = data[len(data) - 1].type_information['type_id']
type_name = data[len(data) - 1].type_information['type_name']
type_list = []
# Filters object list to the current type_id and inserts it into type_list
# When an object is inserted into type_list it gets deleted from object_list
for i in range(len(data) - 1, -1, -1):
if data[i].type_information['type_id'] == type_id:
type_list.append(data[i])
del data[i]
# Runs the requested export function and returns the output in the export variable
export = export_type.export(type_list)
# check if export output is a string, bytes or a file and inserts it into the zip file
if isinstance(export, str) or isinstance(export, bytes):
f.writestr((type_name + "_ID_" + str(type_id) + "." +
export_type.FILE_EXTENSION).format(i), export)
else:
f.writestr((type_name + "_ID_" + str(type_id) + "." +
export_type.FILE_EXTENSION).format(i),
export.getvalue())
# returns zipped file
zipped_file.seek(0)
return zipped_file
def export_file_by_type_id(type_id, export_class, request_user: UserModel):
try:
export_type_class = load_class('cmdb.file_export.export_types.' + export_class)
export_type = export_type_class()
file_export = FileExporter(export_type, type_id)
file_export.objects = file_export.from_database(user=request_user, permission=AccessControlPermission.READ)
except TypeNotFoundError as e:
return abort(400, e.message)
except ModuleNotFoundError as e:
return abort(400, e)
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=e.message))
return file_export.export()
def export_file(request_user: UserModel):
import json
try:
_object_ids = json.loads(request.args.get('ids', []))
_class = request.args.get('classname', '')
_zipping = request.args.get('zip', False) in ['true', 'True']
if _zipping:
export_type_class = load_class('cmdb.file_export.export_types.' + 'ZipExportType')()
file_export = FileExporter(export_type_class, _object_ids, 'object', _class)
else:
export_type_class = load_class('cmdb.file_export.export_types.' + _class)()
file_export = FileExporter(export_type_class, _object_ids, 'object')
file_export.objects = file_export.from_database(user=request_user, permission=AccessControlPermission.READ)
except TypeNotFoundError as e:
return abort(400, e.message)
except ModuleNotFoundError as e:
return abort(400, e)
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=e.message))
return file_export.export()
def convert_to(self):
"""Converts the supported export types inside the list to a passed ExportType type list."""
_list = []
for type_element in self.get_extensions():
type_element_class = load_class('cmdb.file_export.export_types.' +
type_element)
_list.append({
'extension': type_element,
'label': type_element_class.LABEL,
'icon': type_element_class.ICON,
'multiTypeSupport': type_element_class.MULTITYPE_SUPPORT,
'helperText': type_element_class.DESCRIPTION,
'active': type_element_class.ACTIVE
})
return _list
def run_updates(self, version: int, ssr: SystemSettingsReader):
from cmdb.updater import UpdaterModule
ssr.get_all_values_from_section('updater')
updater_instance = UpdaterModule(ssr)
versions = updater_instance.__UPDATER_VERSIONS_POOL__
current_version = updater_instance.get_last_version()['version']
for num, file in enumerate(sorted(versions)):
if current_version > version:
process_bar('Process', len(versions), num + 1)
updater_class = load_class(
f'cmdb.updater.versions.updater_{current_version}.Update{current_version}'
)
updater_instance = updater_class()
updater_instance.start_update()
def start_app(self) -> bool:
"""start all services from service definitions"""
for service_def in self.__service_defs:
service_name = service_def.get_name()
service_class = load_class(service_def.get_class())
process = multiprocessing.Process(target=service_class().start,
name=service_name)
process.start()
self.__process_list.append(process)
# start process controller
proc_controller = ProcessController(process, self.__flag_shutdown,
self.stop_app)
proc_controller.start()
self.__process_controllers.append(proc_controller)
return True
def get_filetypes():
filetypes = FileExporter.get_filetypes()
filetype_list = []
for filetype in filetypes:
filetype_class = load_class('cmdb.file_export.export_types.' + filetype)
filetype_properties = {
'id': filetype,
'label': filetype_class.LABEL,
'icon': filetype_class.ICON,
'multiTypeSupport': filetype_class.MULTITYPE_SUPPORT,
'helperText': filetype_class.DESCRIPTION,
'active': filetype_class.ACTIVE
}
filetype_list.append(filetype_properties)
return make_response(filetype_list)
def get_export_file_types():
_types = FileExporter.get_type_list()
_list = []
for type_element in _types:
type_element_class = load_class('cmdb.file_export.export_types.' + type_element)
type_element_properties = {
'id': type_element,
'label': type_element_class.LABEL,
'icon': type_element_class.ICON,
'multiTypeSupport': type_element_class.MULTITYPE_SUPPORT,
'helperText': type_element_class.DESCRIPTION,
'active': type_element_class.ACTIVE
}
_list.append(type_element_properties)
return make_response(_list)
def export_objects(params: CollectionParameters, request_user: UserModel):
try:
_config = ExporterConfig(parameters=params, options=params.optional)
_class = 'ZipExportType' if params.optional.get('zip', False) in ['true'] \
else params.optional.get('classname', 'JsonExportType')
exporter_class = load_class('cmdb.exporter.exporter_base.' + _class)()
exporter = BaseExportWriter(exporter_class, _config)
exporter.from_database(database_manager=current_app.database_manager, user=request_user,
permission=AccessControlPermission.READ)
except TypeNotFoundError as e:
return abort(400, e.message)
except ModuleNotFoundError as e:
return abort(400, e)
except CMDBError as e:
return abort(404, jsonify(message='Not Found', error=e.message))
return exporter.export()
