class GroupFacade(ModelFacade('group')): def ensure(self, command, reinit): if settings.CLI_EXEC or settings.SCHEDULER_INIT: role_provider = command.get_provider('group', settings.ROLE_PROVIDER) admin_role = self.retrieve(Roles.admin) if not admin_role: admin_role = role_provider.create(Roles.admin, {}) else: admin_role.provider_type = settings.ROLE_PROVIDER admin_role.save() for role, description in Roles.index.items(): if role != 'admin': user_role = self.retrieve(role) if not user_role: user_role = role_provider.create(role) else: user_role.provider_type = settings.ROLE_PROVIDER user_role.parent = admin_role user_role.save() command._user.admin.groups.add(admin_role) def keep(self, key=None): if key: return [] return list(Roles.index.keys())
class UserFacade(ModelFacade('user')): def ensure(self, command, reinit): admin = self.retrieve(settings.ADMIN_USER) if not admin: original_mute = command.mute command.mute = True admin = command.user_provider.create(settings.ADMIN_USER, {}) command.mute = original_mute Runtime.admin_user(admin) def keep(self, key=None): if key: return [] return settings.ADMIN_USER def keep_relations(self): return {'groups': {settings.ADMIN_USER: Roles.admin}} @property def admin(self): return Runtime.admin_user() @property def active_user(self): if not Runtime.active_user(): self.set_active_user(self.admin) return Runtime.active_user() def set_active_user(self, user): Runtime.active_user(user)
class EnvironmentFacade(ModelFacade('environment')): def ensure(self, command, reinit): env_name = self.get_env() env = self.retrieve(env_name) if not env: env = command.environment_provider.create(env_name, {}) if not Runtime.data: env.runtime_image = None env.save() def delete(self, key, **filters): return True def get_env(self): return Runtime.get_env() def set_env(self, name = None, repo = None, image = None): Runtime.set_env(name, repo, image) def delete_env(self): Runtime.delete_env()
class LogFacade(ModelFacade('log')): def get_field_message_render_display(self, instance, value, short): from systems.commands import messages display = [] for record in instance.messages.all().order_by('created'): msg = messages.AppMessage.get(record.data, decrypt=False) display.append(msg.format(True)) return "\n".join(display) + "\n"
class HostFacade(ModelFacade('host')): def get_field_token_display(self, instance, value, short): if value and short: return super().get_field_token_display(instance, value[:10] + '...', short) return super().get_field_token_display(instance, value, short) def get_field_encryption_key_display(self, instance, value, short): if value and short: return super().get_field_encryption_key_display(instance, value[:10] + '...', short) return super().get_field_encryption_key_display(instance, value, short)
class ConfigFacade(ModelFacade('config')): def ensure(self, command, reinit): if settings.CLI_EXEC or settings.SCHEDULER_INIT: terminal_width = command.display_width if not reinit: command.notice("\n".join([ "Loading Zimagi system configurations", "-" * terminal_width ])) command.config_provider.store('environment', { 'value': Environment.get_active_env(), 'value_type': 'str' }, groups=['system']) for setting in self.get_settings(): command.config_provider.store(setting['name'], { 'value': setting['value'], 'value_type': setting['type'] }, groups=['system']) if not reinit: command.notice("-" * terminal_width) def keep(self, key=None): if key: return [] keep = ['environment'] for setting in self.get_settings(): keep.append(setting['name']) return keep @lru_cache(maxsize=None) def get_settings(self): settings_variables = [] for setting in dir(app_settings): if setting == setting.upper(): value = getattr(app_settings, setting) value_type = type(value).__name__ if value_type in ('bool', 'int', 'float', 'str', 'list', 'dict'): settings_variables.append({ 'name': "{}_{}".format(settings.APP_SERVICE.upper(), setting), 'value': value, 'type': value_type }) return settings_variables
class ScheduledTaskFacade(ModelFacade('scheduled_task')): def keep(self, key=None): if key: return [] return [ 'celery.backend_cleanup', 'clean_interval_schedules', 'clean_crontab_schedules', 'clean_datetime_schedules' ] def delete(self, key, **filters): result = super().delete(key, **filters) ScheduledTaskChanges.update_changed() return result def clear(self, **filters): result = super().clear(**filters) ScheduledTaskChanges.update_changed() return result
class GroupFacade(ModelFacade('group')): def ensure(self, command, reinit): admin_group = self.retrieve(Roles.admin) if not admin_group: admin_group = command.group_provider.create(Roles.admin, {}) for role, description in Roles.index.items(): if role != 'admin': group = self.retrieve(role) if not group: group = command.group_provider.create(role) group.parent = admin_group group.save() command._user.admin.groups.add(admin_group) def keep(self, key = None): if key: return [] return list(Roles.index.keys())
class ModuleFacade(ModelFacade('module')): def _ensure(self, command, reinit = False): if settings.DISABLE_MODULE_INIT and not reinit: # Module init calls ensure and we don't want to do it twice in one run return if not reinit: reinit = settings.CLI_EXEC and not command.get_env().runtime_image super()._ensure(command, reinit) def ensure(self, command, reinit): terminal_width = command.display_width if not reinit: command.notice( "\n".join([ "Zimagi needs to build a container with installed module dependencies", "This container will be stored and used in the future,", "so this process is only needed periodically", '', "The requested command will run directly after this initialization", "-" * terminal_width ]) ) command.info("Updating modules from remote sources...") if not self.retrieve(settings.CORE_MODULE): command.options.add('module_provider_name', 'core') command.module_provider.create(settings.CORE_MODULE, {}) for fields in self.manager.index.default_modules: fields = copy.deepcopy(fields) remote = fields.pop('remote', None) provider = fields.pop('provider', 'git') if remote: command.exec_local('module add', { 'module_provider_name': provider, 'remote': remote, 'module_fields': fields }) for module in command.get_instances(self): module.provider.update() module.provider.load_parents() command.info("Ensuring display configurations...") for module in command.get_instances(self): command.exec_local('run', { 'module_name': module.name, 'profile_name': 'display', 'ignore_missing': True }) self.manager.ordered_modules = None command.exec_local('module install', { 'verbosity': command.verbosity }) if not reinit: command.notice("-" * terminal_width) def keep(self, key = None): keep_names = [] if key and self.manager.index.module_dependencies.get(key, None): keep_names = [ key ] elif not key: keep_names = [ settings.CORE_MODULE ] + self.manager.index.get_default_module_names() return keep_names def delete(self, key, **filters): result = super().delete(key, **filters) if result: self.model.save_deploy_modules() return result def clear(self, **filters): result = super().clear(**filters) if result: self.model.save_deploy_modules() return result def get_field_status_display(self, instance, value, short): if value == self.model.STATUS_VALID: return self.success_color(value) return self.error_color(value)
class DataSetFacade(ModelFacade('dataset')): def get_field_data_display(self, instance, value, short): data = instance.provider.load() return "\n" + self.notice_color(data) + "\n"