class SetupRoutine:
class SetupStatus(Enum):
NOT = 0
RUNNING = 1
ERROR = 2
FINISHED = 3
def __init__(self, dbm: DatabaseManagerMongo):
self.status = SetupRoutine.SetupStatus.NOT
# check if settings are loaded
self.setup_system_config_reader = SystemConfigReader()
self.setup_database_manager = dbm
system_config_reader_status = self.setup_system_config_reader.status()
if system_config_reader_status is not True:
self.status = SetupRoutine.SetupStatus.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_setup_status(self):
return self.status
def setup(self) -> SetupStatus:
LOGGER.info('SETUP ROUTINE: STARTED...')
self.status = SetupRoutine.SetupStatus.RUNNING
# check database
if not self.__check_database():
self.status = SetupRoutine.SetupStatus.ERROR
raise RuntimeError(
'The database managers could not be initialized. Perhaps the database cannot be reached, \
or the database was already initialized.')
if self.__is_database_empty():
# init database
try:
self.__init_database()
except Exception as err:
self.status = SetupRoutine.SetupStatus.ERROR
raise RuntimeError(
f'Something went wrong during the initialization of the database. \n Error: {err}'
)
# generate keys
LOGGER.info('SETUP ROUTINE: Generate rsa key pair')
try:
self.init_keys()
except Exception as err:
self.status = SetupRoutine.SetupStatus.ERROR
raise RuntimeError(
f'Something went wrong during the generation of the rsa keypair. \n Error: {err}'
)
# create user management
LOGGER.info('SETUP ROUTINE: UserModel management')
try:
self.__create_user_management()
except Exception as err:
self.status = SetupRoutine.SetupStatus.ERROR
raise RuntimeError(
f'Something went wrong during the generation of the user management. \n Error: {err}'
)
# create version updater settings
try:
from cmdb.updater import UpdaterModule
from cmdb.updater.updater_settings import UpdateSettings
from cmdb.utils.system_reader import SystemSettingsReader
from cmdb.utils.system_writer import SystemSettingsWriter
system_setting_writer: SystemSettingsWriter = SystemSettingsWriter(
self.setup_database_manager)
updater_setting_instance = UpdateSettings(
**UpdaterModule.get_last_version())
system_setting_writer.write(
_id='updater', data=updater_setting_instance.__dict__)
except Exception as err:
self.status = SetupRoutine.SetupStatus.ERROR
raise RuntimeError(
f'Something went wrong during the generation of the updater module. \n Error: {err}'
)
self.status = SetupRoutine.SetupStatus.FINISHED
LOGGER.info('SETUP ROUTINE: FINISHED!')
return self.status
def init_keys(self):
from cmdb.security.key.generator import KeyGenerator
kg = KeyGenerator()
LOGGER.info('KEY ROUTINE: Generate RSA keypair')
kg.generate_rsa_keypair()
LOGGER.info('KEY ROUTINE: Generate aes key')
kg.generate_symmetric_aes_key()
self.__check_database()
from cmdb.user_management.managers.user_manager import UserManager, UserModel
from cmdb.security.security import SecurityManager
scm = SecurityManager(self.setup_database_manager)
usm = UserManager(self.setup_database_manager)
try:
admin_user: UserModel = usm.get(1)
LOGGER.warning('KEY ROUTINE: Admin user detected')
LOGGER.info(
f'KEY ROUTINE: Enter new password for user: {admin_user.user_name}'
)
admin_pass = str(input('New admin password: '******'KEY ROUTINE: Password was updated for user: {admin_user.user_name}'
)
except Exception as ex:
LOGGER.info(
f'KEY ROUTINE: Password was updated for user failed: {ex}')
LOGGER.info('KEY ROUTINE: FINISHED')
def __create_user_management(self):
from cmdb.user_management.models.user import UserModel
from cmdb.user_management.managers.user_manager import UserManager
from cmdb.user_management.managers.group_manager import GroupManager
from cmdb.user_management import __FIXED_GROUPS__
from cmdb.security.security import SecurityManager
scm = SecurityManager(self.setup_database_manager)
group_manager = GroupManager(self.setup_database_manager)
user_manager = UserManager(self.setup_database_manager)
for group in __FIXED_GROUPS__:
group_manager.insert(group)
# setting the initial user to admin/admin as default
admin_name = 'admin'
admin_pass = '******'
import datetime
admin_user = UserModel(
public_id=1,
user_name=admin_name,
active=True,
group_id=__FIXED_GROUPS__[0].get_public_id(),
registration_time=datetime.datetime.now(),
password=scm.generate_hmac(admin_pass),
)
user_manager.insert(admin_user)
return True
def __check_database(self):
LOGGER.info('SETUP ROUTINE: Checking database connection')
from cmdb.database.errors.connection_errors import ServerTimeoutError
try:
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 __init_database(self):
database_name = self.setup_system_config_reader.get_value(
'database_name', 'Database')
LOGGER.info(f'SETUP ROUTINE: initialize database {database_name}')
# delete database
try:
self.setup_database_manager.drop_database(database_name)
except DatabaseNotExists as err:
LOGGER.error(err.message)
# create new database
self.setup_database_manager.create_database(database_name)
# generate collections
# framework collections
from cmdb.framework import __COLLECTIONS__ as FRAMEWORK_CLASSES
for collection in FRAMEWORK_CLASSES:
self.setup_database_manager.create_collection(
collection.COLLECTION)
# set unique indexes
self.setup_database_manager.create_indexes(
collection.COLLECTION, collection.get_index_keys())
# user management collections
from cmdb.user_management import __COLLECTIONS__ as USER_MANAGEMENT_COLLECTION
for collection in USER_MANAGEMENT_COLLECTION:
self.setup_database_manager.create_collection(
collection.COLLECTION)
# set unique indexes
self.setup_database_manager.create_indexes(
collection.COLLECTION, collection.get_index_keys())
# ExportdJob management collections
from cmdb.exportd import __COLLECTIONS__ as JOB_MANAGEMENT_COLLECTION
for collection in JOB_MANAGEMENT_COLLECTION:
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('SETUP ROUTINE: initialize finished')
def create_rest_api(event_queue):
from cmdb.interface.config import app_config
from cmdb.utils.system_config import SystemConfigReader
system_config_reader = SystemConfigReader()
try:
cache_config = {
'DEBUG':
True,
'CACHE_TYPE':
system_config_reader.get_value('name', 'Cache'),
'CACHE_REDIS_HOST':
system_config_reader.get_value('host', 'Cache'),
'CACHE_REDIS_PORT':
system_config_reader.get_value('port', 'Cache'),
'CACHE_REDIS_PASSWORD':
system_config_reader.get_value('password', 'Cache'),
}
except (ImportError, CMDBError) as e:
LOGGER.debug(e.message)
cache_config = {'CACHE_TYPE': 'simple'}
from flask_caching import Cache
cache = Cache(config=cache_config)
# Create manager
from cmdb.data_storage.database_manager 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)
# Import App Extensions
from flask_cors import CORS
CORS(app)
import cmdb
cache.init_app(app)
cache.clear()
app.cache = cache
if cmdb.__MODE__ == 'DEBUG':
app.config.from_object(app_config['rest_development'])
LOGGER.info('RestAPI starting with config mode {}'.format(
app.config.get("ENV")))
elif cmdb.__MODE__ == 'TESTING':
app.config.from_object(app_config['testing'])
else:
app.config.from_object(app_config['rest'])
LOGGER.info('RestAPI starting with config mode {}'.format(
app.config.get("ENV")))
with app.app_context():
register_converters(app)
register_error_pages(app)
register_blueprints(app)
return app