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 has_updates(self) -> bool:
"""
check if updates are available
Returns: True else raise error
"""
from cmdb.updater import UpdaterModule
from cmdb.utils.system_reader import SystemSettingsReader, SectionError
try:
ssr = SystemSettingsReader(self.setup_database_manager)
ssr.get_all_values_from_section('updater')
upd_module = UpdaterModule(ssr)
new_version = upd_module.get_last_version()['version']
current_version = upd_module.settings.version
if new_version > current_version:
LOGGER.error(
f'Please run an update. There are new updates available.'
f'Current Updater Version: {current_version} '
f'Newest Update Version: {new_version}'
)
return False
except SectionError as err:
LOGGER.error(err.message)
return False
return True
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}'
)
def parse_authorization_header(header):
"""
Parses the HTTP Auth Header to a JWT Token
Args:
header: Authorization header of the HTTP Request
Examples:
request.headers['Authorization'] or something same
Returns:
Valid JWT token
"""
if not header:
return None
value = wsgi_to_bytes(header)
try:
auth_type, auth_info = value.split(None, 1)
auth_type = auth_type.lower()
except ValueError:
# Fallback for old versions
auth_type = b"bearer"
auth_info = value
if auth_type == b"basic":
try:
username, password = base64.b64decode(auth_info).split(b":", 1)
with current_app.app_context():
username = to_unicode(username, "utf-8")
password = to_unicode(password, "utf-8")
user_manager: UserManager = UserManager(
current_app.database_manager)
auth_module = AuthModule(
SystemSettingsReader(current_app.database_manager))
try:
user_instance = auth_module.login(user_manager, username,
password)
except Exception as e:
return None
if user_instance:
tg = TokenGenerator(current_app.database_manager)
return tg.generate_token(payload={
'user': {
'public_id': user_instance.get_public_id()
}
})
else:
return None
except Exception:
return None
if auth_type == b"bearer":
try:
tv = TokenValidator()
decoded_token = tv.decode_token(auth_info)
tv.validate_token(decoded_token)
return auth_info
except Exception:
return None
return None
def __init__(self, database_manager: DatabaseManagerMongo):
"""
Args:
key_directory: key based directory
"""
self.ssr = SystemSettingsReader(database_manager)
self.rsa_public = self.get_public_key()
self.rsa_private = self.get_private_key()
def __init__(self, database_manager: DatabaseManagerMongo = None):
self.key_holder = KeyHolder(database_manager)
self.header = {'alg': 'RS512'}
self.database_manager = database_manager
self.auth_module = AuthModule(
SystemSettingsReader(
self.database_manager).get_all_values_from_section(
'auth', default=AuthModule.__DEFAULT_SETTINGS__))
def increase_updater_version(self, value: int):
ssr = SystemSettingsReader(self.database_manager)
system_setting_writer: SystemSettingsWriter = SystemSettingsWriter(
self.database_manager)
updater_settings_values = ssr.get_all_values_from_section('updater')
updater_setting_instance = UpdateSettings(**updater_settings_values)
updater_setting_instance.version = value
system_setting_writer.write(_id='updater',
data=updater_setting_instance.__dict__)
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 __init__(self, database_manager):
self.ssr = SystemSettingsReader(database_manager)
self.ssw = SystemSettingsWriter(database_manager)
self.salt = "cmdb"
LOGGER = logging.getLogger(__name__)
try:
from cmdb.utils.error import CMDBError
except ImportError:
CMDBError = Exception
settings_blueprint = RootBlueprint('settings_rest',
__name__,
url_prefix='/settings')
with current_app.app_context():
from cmdb.interface.rest_api.settings_routes.system_routes import system_blueprint
settings_blueprint.register_nested_blueprint(system_blueprint)
system_settings_reader = SystemSettingsReader(
database_manager=current_app.database_manager)
@settings_blueprint.route('/<string:section>/', methods=['GET'])
@settings_blueprint.route('/<string:section>', methods=['GET'])
@login_required
@insert_request_user
@right_required('base.system.view')
def get_settings_from_section(section: str, request_user: User):
section_settings = system_settings_reader.get_all_values_from_section(
section=section)
if len(section_settings) < 1:
return make_response([], 204)
return make_response(section_settings)