def __check_database(self):
LOGGER.info('SETUP ROUTINE: Checking database connection')
from cmdb.database.managers import DatabaseManagerMongo
from cmdb.database.errors.connection_errors import ServerTimeoutError
try:
self.setup_database_manager = DatabaseManagerMongo(
**self.setup_system_config_reader.get_all_values_from_section(
'Database'))
connection_test = self.setup_database_manager.connector.is_connected(
)
except ServerTimeoutError:
connection_test = False
LOGGER.info(
f'SETUP ROUTINE: Database connection status {connection_test}')
return connection_test
def __init__(self,
file,
file_type,
config: ObjectImporterConfig = None,
parser: BaseObjectParser = None,
object_manager: CmdbObjectManager = None,
request_user: UserModel = None):
"""
Basic importer super class for object imports
Normally should be started by start_import
Args:
file: File instance, name, content or loaded path to file
file_type: file type - used with content-type
config: importer configuration
parser: the parser instance based on content-type
object_manager: a instance of the object managers
request_user: the instance of the started user
"""
self.parser = parser
if object_manager:
self.object_manager = object_manager
else:
from cmdb.utils.system_config import SystemConfigReader
from cmdb.database.managers import DatabaseManagerMongo
object_manager = CmdbObjectManager(
database_manager=DatabaseManagerMongo(**SystemConfigReader(
).get_all_values_from_section('Database')))
self.object_manager = object_manager
self.request_user = request_user
super(ObjectImporter, self).__init__(file=file,
file_type=file_type,
config=config)
def _check_database():
"""
Checks whether the specified connection of the configuration is reachable.
Returns: Datebase if response
"""
from cmdb.database.errors.connection_errors import ServerTimeoutError
ssc = SystemConfigReader()
LOGGER.info(f'Checking database connection with {ssc.config_name} data')
database_options = ssc.get_all_values_from_section('Database')
dbm = DatabaseManagerMongo(**database_options)
try:
connection_test = dbm.connector.is_connected()
except ServerTimeoutError:
connection_test = False
LOGGER.debug(f'Database status is {connection_test}')
if connection_test is True:
return dbm
retries = 0
while retries < 3:
retries += 1
LOGGER.warning(
f'Retry {retries}: Checking database connection with {SystemConfigReader.DEFAULT_CONFIG_NAME} data'
)
connection_test = dbm.connector.is_connected()
if connection_test:
return dbm
return None
def __init__(self, database_manager: DatabaseManagerMongo = None):
self.key_holder = KeyHolder()
self.header = {'alg': 'RS512'}
self.database_manager = database_manager or DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database'))
self.auth_module = AuthModule(
SystemSettingsReader(self.database_manager))
def authenticate(self, user_name: str, password: str, **kwargs) -> UserModel:
__dbm = DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database')
)
__user_manager = UserManager(__dbm)
try:
ldap_connection_status = self.connect()
LOGGER.debug(f'[LdapAuthenticationProvider] Connection status: {ldap_connection_status}')
except Exception as e:
LOGGER.error(f'[LdapAuthenticationProvider] Failed to connect to LDAP server - error: {e}')
raise AuthenticationError(LdapAuthenticationProvider.get_name(), e)
ldap_search_filter = self.config.search['searchfilter'].replace("%username%", user_name)
LOGGER.debug(f'[LdapAuthenticationProvider] Search Filter: {ldap_search_filter}')
search_result = self.__ldap_connection.search(self.config.search['basedn'], ldap_search_filter)
LOGGER.debug(f'[LdapAuthenticationProvider] Search result: {search_result}')
if not search_result or len(self.__ldap_connection.entries) == 0:
raise AuthenticationError(LdapAuthenticationProvider.get_name(), 'No matching entry')
for entry in self.__ldap_connection.entries:
LOGGER.debug(f'[LdapAuthenticationProvider] Entry: {entry}')
entry_dn = entry.entry_dn
try:
entry_connection_result = LdapAuthenticationProvider.Connection(self.__ldap_server, entry_dn, password,
auto_bind=True)
LOGGER.debug(f'[LdapAuthenticationProvider] UserModel connection result: {entry_connection_result}')
except Exception as e:
LOGGER.error(f'[LdapAuthenticationProvider] UserModel auth result: {e}')
raise AuthenticationError(LdapAuthenticationProvider.get_name(), e)
# Check if user exists
try:
user_instance: UserModel = __user_manager.get_by({'user_name': user_name})
except ManagerGetError as umge:
LOGGER.warning(f'[LdapAuthenticationProvider] UserModel exists on LDAP but not in database: {umge}')
LOGGER.debug(f'[LdapAuthenticationProvider] Try creating user: {user_name}')
try:
new_user_data = dict()
new_user_data['user_name'] = user_name
new_user_data['active'] = True
new_user_data['group_id'] = self.config.default_group
new_user_data['registration_time'] = datetime.now()
new_user_data['authenticator'] = LdapAuthenticationProvider.get_name()
except Exception as e:
LOGGER.debug(f'[LdapAuthenticationProvider] {e}')
raise AuthenticationError(LdapAuthenticationProvider.get_name(), e)
LOGGER.debug(f'[LdapAuthenticationProvider] New user was init')
try:
user_id = __user_manager.insert(new_user_data)
except ManagerInsertError as umie:
LOGGER.debug(f'[LdapAuthenticationProvider] {umie}')
raise AuthenticationError(LdapAuthenticationProvider.get_name(), umie)
try:
user_instance: UserModel = __user_manager.get(public_id=user_id)
except ManagerGetError as umge:
LOGGER.debug(f'[LdapAuthenticationProvider] {umge}')
raise AuthenticationError(LdapAuthenticationProvider.get_name(), umge)
return user_instance
def __init__(self):
scr = SystemConfigReader()
self.database_manager = DatabaseManagerMongo(
**scr.get_all_values_from_section('Database'))
self.object_manager = CmdbObjectManager(
database_manager=self.database_manager)
self.log_manager = ExportdLogManager(
database_manager=self.database_manager)
super().__init__(self.database_manager)
def __init__(self, object_list: List[CmdbObject], request_user: UserModel, dt_render=False, ref_render=False,
object_manager: CmdbObjectManager = None):
self.object_list: List[CmdbObject] = object_list
self.request_user = request_user
self.dt_render = dt_render
self.ref_render = ref_render
from cmdb.utils.system_config import SystemConfigReader
database_manager = DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database')
)
self.object_manager = object_manager or CmdbObjectManager(database_manager=database_manager)
self.user_manager = UserManager(database_manager=database_manager)
def __init__(self, key_directory=None):
"""
Args:
key_directory: key based directory
"""
self.scr = SystemConfigReader()
self.__dbm = DatabaseManagerMongo(
**self.scr.get_all_values_from_section('Database')
)
self.ssr = SystemSettingsReader(self.__dbm)
self.rsa_public = self.get_public_key()
self.rsa_private = self.get_private_key()
def authenticate(self, user_name: str, password: str, **kwargs) -> UserModel:
__dbm = DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database')
)
__scm = SecurityManager(__dbm)
__user_manager = UserManager(__dbm)
LOGGER.info(f'[LocalAuthenticationProvider] Try login for user {user_name}')
try:
user: UserModel = __user_manager.get_by({'user_name': user_name})
except ManagerGetError as umge:
raise AuthenticationError(LocalAuthenticationProvider.get_name(), umge.message)
login_pass = __scm.generate_hmac(password)
if login_pass == user.password:
return user
raise AuthenticationError(LocalAuthenticationProvider.get_name(), 'UserModel not exists')
def __init__(self, event, state=False):
super(ExportdThread, self).__init__()
self.job = None
self.job_id = event.get_param("id")
self.type_id = event.get_param("type_id")
self.user_id = event.get_param("user_id")
self.event = event
self.is_active = state
self.exception_handling = None
scr = SystemConfigReader()
database_options = scr.get_all_values_from_section('Database')
self.__dbm = DatabaseManagerMongo(**database_options)
self.log_manager = ExportdLogManager(database_manager=self.__dbm)
self.exportd_job_manager = ExportdJobManagement(
database_manager=self.__dbm)
self.user_manager = UserManager(database_manager=self.__dbm)
def __init__(self, job: ExportdJob):
self.job = job
self.exportvars = self.__get_exportvars()
self.destinations = self.__get__destinations()
scr = SystemConfigReader()
database_manager = DatabaseManagerMongo(
**scr.get_all_values_from_section('Database')
)
self.__object_manager = CmdbObjectManager(
database_manager=database_manager
)
self.log_manager = ExportdLogManager(
database_manager=database_manager)
self.sources = self.__get_sources()
super(ExportdManagerBase, self).__init__(database_manager)
def create_docs_server(event_queue):
# Create managers
from cmdb.database.managers import DatabaseManagerMongo
app_database = DatabaseManagerMongo(
**system_config_reader.get_all_values_from_section('Database')
)
app = BaseCmdbApp(__name__, app_database)
if cmdb.__MODE__ == 'DEBUG':
config = app_config['development']
config.APPLICATION_ROOT = '/docs/'
app.config.from_object(config)
else:
config = app_config['production']
config.APPLICATION_ROOT = '/docs/'
app.config.from_object(config)
app.register_blueprint(doc_pages, url_prefix="/")
return app
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 create_app(event_queue):
# Create managers
from cmdb.database.managers import DatabaseManagerMongo
app_database = DatabaseManagerMongo(
**system_config_reader.get_all_values_from_section('Database'))
app = BaseCmdbApp(__name__, app_database)
CORS(app)
import cmdb
from cmdb.interface.net_app.app_routes import app_pages, redirect_index
if cmdb.__MODE__ == 'DEBUG':
config = app_config['development']
app.config.from_object(config)
else:
config = app_config['production']
app.config.from_object(config)
# add static routes
app.register_blueprint(app_pages, url_prefix='/')
app.register_error_handler(404, redirect_index)
@app.route('/favicon.ico')
def favicon():
from os import path
from flask import send_from_directory
return send_from_directory(path.join(app.root_path, '_static'),
'favicon.ico')
@app.route('/browserconfig.xml')
def browser_config():
from os import path
from flask import send_from_directory
return send_from_directory(path.join(app.root_path, '_static'),
'browserconfig.xml')
return app
def _run(self):
# get queue for sending events
event_queue = self._event_manager.get_send_queue()
database_manager = DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database'))
# get WSGI app
app = DispatcherMiddleware(app=create_app(),
mounts={
'/docs':
create_docs_server(),
'/rest':
create_rest_api(database_manager,
event_queue)
})
# get gunicorn options
options = SystemConfigReader().get_all_values_from_section('WebServer')
# start gunicorn as own process
webserver = HTTPServer(app, options)
self.__webserver_proc = multiprocessing.Process(target=webserver.run)
self.__webserver_proc.start()
self.__webserver_proc.join()
def create_rest_api(event_queue):
from cmdb.interface.config import app_config
from cmdb.utils.system_config import SystemConfigReader
system_config_reader = SystemConfigReader()
# Create managers
from cmdb.database.managers import DatabaseManagerMongo
app_database = DatabaseManagerMongo(
**system_config_reader.get_all_values_from_section('Database'))
object_manager = CmdbObjectManager(database_manager=app_database,
event_queue=event_queue)
log_manager = CmdbLogManager(database_manager=app_database)
security_manager = SecurityManager(database_manager=app_database)
user_manager = UserManager(database_manager=app_database)
exportd_job_manager = ExportdJobManagement(database_manager=app_database,
event_queue=event_queue)
exportd_log_manager = ExportdLogManager(database_manager=app_database)
media_file_manager = MediaFileManagement(database_manager=app_database)
docapi_tpl_manager = DocapiTemplateManager(database_manager=app_database)
# Create APP
from cmdb.interface.cmdb_app import BaseCmdbApp
app = BaseCmdbApp(__name__,
database_manager=app_database,
docapi_tpl_manager=docapi_tpl_manager,
media_file_manager=media_file_manager,
exportd_manager=exportd_job_manager,
exportd_log_manager=exportd_log_manager,
object_manager=object_manager,
log_manager=log_manager,
user_manager=user_manager,
security_manager=security_manager)
app.url_map.strict_slashes = True
# Import App Extensions
from flask_cors import CORS
CORS(app, expose_headers=['X-API-Version', 'X-Total-Count'])
import cmdb
if cmdb.__MODE__ == 'DEBUG':
config = app_config['development']
config.APPLICATION_ROOT = '/rest/'
app.config.from_object(config)
else:
config = app_config['production']
config.APPLICATION_ROOT = '/rest/'
app.config.from_object(config)
with app.app_context():
register_converters(app)
register_error_pages(app)
register_blueprints(app)
return app
def database_manager(mongodb_parameters):
host, port, database = mongodb_parameters
return DatabaseManagerMongo(host, port, database)
class UpdateRoutine:
class UpateStatus(Enum):
NOT = 0
RUNNING = 1
ERROR = 2
FINISHED = 3
def __init__(self):
self.status = UpdateRoutine.UpateStatus.NOT
# check if settings are loaded
from cmdb.utils.system_config import SystemConfigReader
self.setup_system_config_reader = SystemConfigReader()
system_config_reader_status = self.setup_system_config_reader.status()
if system_config_reader_status is not True:
self.status = UpdateRoutine.UpateStatus.ERROR
raise RuntimeError(
f'The system configuration files were loaded incorrectly or nothing has been loaded at all. - \
system config reader status: {system_config_reader_status}'
)
def get_updater_status(self):
return self.status
def __check_database(self):
LOGGER.info('SETUP ROUTINE: Checking database connection')
from cmdb.database.managers import DatabaseManagerMongo
from cmdb.database.errors.connection_errors import ServerTimeoutError
try:
self.setup_database_manager = DatabaseManagerMongo(
**self.setup_system_config_reader.get_all_values_from_section(
'Database'))
connection_test = self.setup_database_manager.connector.is_connected(
)
except ServerTimeoutError:
connection_test = False
LOGGER.info(
f'SETUP ROUTINE: Database connection status {connection_test}')
return connection_test
def __is_database_empty(self) -> bool:
return not self.setup_database_manager.connector.database.list_collection_names(
)
def start_update(self):
LOGGER.info('UPDATE ROUTINE: Update database collection')
self.status = UpdateRoutine.UpateStatus.RUNNING
# check database
if not self.__check_database():
self.status = UpdateRoutine.UpateStatus.ERROR
raise RuntimeError(
'The database managers could not be initialized. Perhaps the database cannot be reached, \
or the database was already initialized.')
if not self.__is_database_empty():
self.update_database_collection()
self.update_db_version()
else:
LOGGER.info(
'UPDATE ROUTINE: The update is faulty because no collection was detected.'
)
LOGGER.info('UPDATE ROUTINE: Update database collection finished.')
self.status = UpdateRoutine.UpateStatus.FINISHED
LOGGER.info('UPDATE ROUTINE: FINISHED!')
return self.status
def update_database_collection(self):
from cmdb.framework import __COLLECTIONS__ as FRAMEWORK_CLASSES
from cmdb.user_management import __COLLECTIONS__ as USER_MANAGEMENT_COLLECTION
from cmdb.exportd import __COLLECTIONS__ as JOB_MANAGEMENT_COLLECTION
# update database collections
try:
detected_database = self.setup_database_manager.connector.database
# update collections
# framework collections
for collection in FRAMEWORK_CLASSES:
try:
detected_database.validate_collection(
collection.COLLECTION)['valid']
except:
self.setup_database_manager.create_collection(
collection.COLLECTION)
# set unique indexes
self.setup_database_manager.create_indexes(
collection.COLLECTION, collection.get_index_keys())
LOGGER.info(
f'UPDATE ROUTINE: Database collection {collection.COLLECTION} was created.'
)
# user management collections
for collection in USER_MANAGEMENT_COLLECTION:
try:
detected_database.validate_collection(
collection.COLLECTION)['valid']
except:
self.setup_database_manager.create_collection(
collection.COLLECTION)
# set unique indexes
self.setup_database_manager.create_indexes(
collection.COLLECTION, collection.get_index_keys())
LOGGER.info(
f'UPDATE ROUTINE: Database collection {collection.COLLECTION} was created.'
)
# exportdJob management collections
for collection in JOB_MANAGEMENT_COLLECTION:
try:
detected_database.validate_collection(
collection.COLLECTION)['valid']
except:
self.setup_database_manager.create_collection(
collection.COLLECTION)
# set unique indexes
self.setup_database_manager.create_indexes(
collection.COLLECTION, collection.get_index_keys())
LOGGER.info(
f'UPDATE ROUTINE: Database collection {collection.COLLECTION} was created.'
)
except Exception as ex:
LOGGER.info(
f'UPDATE ROUTINE: Database collection validation failed: {ex}')
def update_db_version(self):
# update version updater settings
try:
updater_settings_values = UpdaterModule.__DEFAULT_SETTINGS__
ssr = SystemSettingsReader(self.setup_database_manager)
try:
updater_settings_values = ssr.get_all_values_from_section(
'updater')
updater_setting_instance = UpdateSettings(
**updater_settings_values)
except Exception:
# create updater section if not exist
system_setting_writer: SystemSettingsWriter = SystemSettingsWriter(
self.setup_database_manager)
updater_setting_instance = UpdateSettings(
**updater_settings_values)
system_setting_writer.write(
_id='updater', data=updater_setting_instance.__dict__)
# start running update files
updater_setting_instance.run_updates(
updater_settings_values.get('version'), ssr)
except Exception as err:
self.status = UpdateRoutine.UpateStatus.ERROR
raise RuntimeError(
f'Something went wrong during the generation of the updater module. \n Error: {err}'
)
import openpyxl
from typing import List
from cmdb.utils import json_encoding
from cmdb.utils.helpers import load_class
from cmdb.utils.system_config import SystemConfigReader
from cmdb.database.managers import DatabaseManagerMongo
from cmdb.exporter.exporter_utils import ExperterUtils
from cmdb.exporter.format.format_base import BaseExporterFormat
from cmdb.exporter.config.config_type import ExporterConfigType
from cmdb.framework.managers.type_manager import TypeManager
from cmdb.framework.cmdb_object_manager import CmdbObjectManager
from cmdb.framework.cmdb_render import RenderResult
database_manager = DatabaseManagerMongo(
**SystemConfigReader().get_all_values_from_section('Database'))
object_manager = CmdbObjectManager(database_manager=database_manager)
type_manager = TypeManager(database_manager=database_manager)
class ZipExportType(BaseExporterFormat):
FILE_EXTENSION = "zip"
LABEL = "ZIP"
MULTITYPE_SUPPORT = True
ICON = "file-archive"
DESCRIPTION = "Export Zipped Files"
ACTIVE = True
def export(self, data: List[RenderResult], *args):
"""