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"