def ready(self):
from waldur_core.structure.registry import SupportedServices
from waldur_core.structure import models as structure_models
from waldur_openstack.openstack_tenant.models import Instance
from .backend import RancherBackend
from . import handlers, models, signals as rancher_signals
SupportedServices.register_backend(RancherBackend)
rancher_signals.rancher_user_created.connect(
handlers.notify_create_user,
sender=models.RancherUser,
dispatch_uid='waldur_rancher.notify_create_user',
)
signals.post_delete.connect(
handlers.delete_node_if_related_instance_has_been_deleted,
sender=Instance,
dispatch_uid=
'waldur_rancher.delete_node_if_related_instance_has_been_deleted',
)
signals.post_delete.connect(
handlers.delete_cluster_if_all_related_nodes_have_been_deleted,
sender=models.Node,
dispatch_uid=
'waldur_rancher.delete_cluster_if_all_related_nodes_have_been_deleted',
)
signals.post_save.connect(
handlers.
set_error_state_for_node_if_related_instance_deleting_is_failed,
sender=Instance,
dispatch_uid=
'waldur_rancher.set_error_state_for_node_if_related_instance_deleting_is_failed',
)
signals.post_save.connect(
handlers.
set_error_state_for_cluster_if_related_node_deleting_is_failed,
sender=models.Node,
dispatch_uid=
'waldur_rancher.set_error_state_for_cluster_if_related_node_deleting_is_failed',
)
for klass in (models.Project, models.Cluster,
structure_models.ServiceSettings):
signals.post_delete.connect(
handlers.delete_catalog_if_scope_has_been_deleted,
sender=klass,
dispatch_uid=
'waldur_rancher.delete_catalog_if_scope_has_been_deleted_(%s)'
% klass.__name__,
)
def ready(self):
from waldur_core.quotas import fields as quota_fields
from waldur_core.structure.registry import SupportedServices
from waldur_core.structure import models as structure_models
from waldur_core.structure.signals import resource_imported
from . import handlers
from .backend import JiraBackend
SupportedServices.register_backend(JiraBackend)
Issue = self.get_model('Issue')
Comment = self.get_model('Comment')
Project = self.get_model('Project')
structure_models.Project.add_quota_field(
name='nc_jira_project_count',
quota_field=quota_fields.CounterQuotaField(
target_models=lambda: [Project],
path_to_scope='project',
),
)
resource_imported.connect(
handlers.import_project_issues,
sender=Project,
dispatch_uid='waldur_jira.handlers.import_project_issues',
)
signals.post_save.connect(
handlers.log_issue_save,
sender=Issue,
dispatch_uid='waldur_jira.handlers.log_issue_save',
)
signals.post_delete.connect(
handlers.log_issue_delete,
sender=Issue,
dispatch_uid='waldur_jira.handlers.log_issue_delete',
)
signals.post_save.connect(
handlers.log_comment_save,
sender=Comment,
dispatch_uid='waldur_jira.handlers.log_comment_save',
)
signals.post_delete.connect(
handlers.log_comment_delete,
sender=Comment,
dispatch_uid='waldur_jira.handlers.log_comment_delete',
)
def get_field_type(field):
"""
Returns field type/possible values.
"""
if isinstance(field, core_filters.MappedMultipleChoiceFilter):
return ' | '.join(['"%s"' % f for f in sorted(field.mapped_to_model)])
if isinstance(field, OrderingFilter) or isinstance(field, ChoiceFilter):
return ' | '.join(['"%s"' % f[0] for f in field.extra['choices']])
if isinstance(field, ChoiceField):
return ' | '.join(['"%s"' % f for f in sorted(field.choices)])
if isinstance(field, HyperlinkedRelatedField):
if field.view_name.endswith('detail'):
return 'link to %s' % reverse(
field.view_name,
kwargs={
'%s' % field.lookup_field: "'%s'" % field.lookup_field
},
)
return reverse(field.view_name)
if isinstance(field, structure_filters.ServiceTypeFilter):
return ' | '.join([
'"%s"' % f for f in SupportedServices.get_filter_mapping().keys()
])
if isinstance(field, core_serializers.GenericRelatedField):
links = []
for model in field.related_models:
detail_view_name = core_utils.get_detail_view_name(model)
for f in field.lookup_fields:
try:
link = reverse(detail_view_name,
kwargs={'%s' % f: "'%s'" % f})
except NoReverseMatch:
pass
else:
links.append(link)
break
path = ', '.join(links)
if path:
return 'link to any: %s' % path
if isinstance(field, core_filters.ContentTypeFilter):
return "string in form 'app_label'.'model_name'"
if isinstance(field, ModelMultipleChoiceFilter):
return get_field_type(field.field)
if isinstance(field, ListSerializer):
return 'list of [%s]' % get_field_type(field.child)
if isinstance(field, ManyRelatedField):
return 'list of [%s]' % get_field_type(field.child_relation)
if isinstance(field, ModelField):
return get_field_type(field.model_field)
name = field.__class__.__name__
for w in ('Filter', 'Field', 'Serializer'):
name = name.replace(w, '')
return FIELDS.get(name, name)
def ready(self):
from waldur_core.structure.registry import SupportedServices
from .backend import VMwareBackend
from . import handlers, models
SupportedServices.register_backend(VMwareBackend)
signals.post_save.connect(
handlers.update_vm_total_disk_when_disk_is_created_or_updated,
sender=models.Disk,
dispatch_uid='waldur_vmware.handlers.'
'update_vm_total_disk_when_disk_is_created_or_updated',
)
signals.post_delete.connect(
handlers.update_vm_total_disk_when_disk_is_deleted,
sender=models.Disk,
dispatch_uid='waldur_vmware.handlers.'
'update_vm_total_disk_when_disk_is_deleted',
)
def ready(self):
from waldur_core.structure.registry import SupportedServices
from .backend import AWSBackend
SupportedServices.register_backend(AWSBackend)
def lookups(self, request, model_admin):
return SupportedServices.get_choices()
def __init__(self, *args, **kwargs):
super(ServiceSettingsAdminForm, self).__init__(*args, **kwargs)
self.fields['type'] = ChoiceField(
choices=SupportedServices.get_choices(), widget=RadioSelect
)
def get_backend(self, **kwargs):
return SupportedServices.get_service_backend(self.type)(self, **kwargs)
def validate_service_type(service_type):
from django.core.exceptions import ValidationError
if not SupportedServices.has_service_type(service_type):
raise ValidationError(_('Invalid service type.'))
def filter(self, qs, value):
value = SupportedServices.get_filter_mapping().get(value)
return super(ServiceTypeFilter, self).filter(qs, value)
def ready(self):
SupportedServices.register_backend(TestBackend)
def ready(self):
from waldur_core.quotas.fields import QuotaField, TotalQuotaField
from waldur_core.quotas.models import Quota
from waldur_core.structure.models import (
ServiceSettings,
Project,
Customer,
SharedServiceSettings,
)
from waldur_core.structure.registry import SupportedServices
from waldur_openstack.openstack.models import Tenant, SecurityGroupRule
from .backend import OpenStackTenantBackend
from . import handlers, models
SupportedServices.register_backend(OpenStackTenantBackend)
# Initialize service settings quotas based on tenant.
for quota in Tenant.get_quotas_fields():
ServiceSettings.add_quota_field(
name=quota.name,
quota_field=QuotaField(
is_backend=True,
default_limit=quota.default_limit,
creation_condition=lambda service_settings:
service_settings.type == OpenStackTenantConfig.
service_name,
),
)
signals.post_save.connect(
handlers.sync_private_settings_quotas_with_tenant_quotas,
sender=Quota,
dispatch_uid=
'openstack_tenant.handlers.sync_private_settings_quotas_with_tenant_quotas',
)
signals.post_save.connect(
handlers.
propagate_volume_type_quotas_from_tenant_to_private_service_settings,
sender=Quota,
dispatch_uid=
'openstack_tenant.handlers.propagate_volume_type_quotas_from_tenant_to_private_service_settings',
)
signals.post_delete.connect(
handlers.delete_volume_type_quotas_from_private_service_settings,
sender=Quota,
dispatch_uid=
'openstack_tenant.handlers.delete_volume_type_quotas_from_private_service_settings',
)
Project.add_quota_field(
name='os_cpu_count',
quota_field=TotalQuotaField(
target_models=[models.Instance],
path_to_scope='project',
target_field='cores',
),
)
Project.add_quota_field(
name='os_ram_size',
quota_field=TotalQuotaField(
target_models=[models.Instance],
path_to_scope='project',
target_field='ram',
),
)
Project.add_quota_field(
name='os_storage_size',
quota_field=TotalQuotaField(
target_models=[models.Volume, models.Snapshot],
path_to_scope='project',
target_field='size',
),
)
Customer.add_quota_field(
name='os_cpu_count',
quota_field=TotalQuotaField(
target_models=[models.Instance],
path_to_scope='project.customer',
target_field='cores',
),
)
Customer.add_quota_field(
name='os_ram_size',
quota_field=TotalQuotaField(
target_models=[models.Instance],
path_to_scope='project.customer',
target_field='ram',
),
)
Customer.add_quota_field(
name='os_storage_size',
quota_field=TotalQuotaField(
target_models=[models.Volume, models.Snapshot],
path_to_scope='project.customer',
target_field='size',
),
)
for Resource in (models.Instance, models.Volume, models.Snapshot):
name = Resource.__name__.lower()
signals.post_save.connect(
handlers.log_action,
sender=Resource,
dispatch_uid='openstack_tenant.handlers.log_%s_action' % name,
)
for handler in handlers.resource_handlers:
model = handler.resource_model
name = model.__name__.lower()
fsm_signals.post_transition.connect(
handler.create_handler,
sender=model,
dispatch_uid='openstack_tenant.handlers.create_%s' % name,
)
fsm_signals.post_transition.connect(
handler.update_handler,
sender=model,
dispatch_uid='openstack_tenant.handlers.update_%s' % name,
)
signals.post_save.connect(
handler.import_handler,
sender=model,
dispatch_uid='openstack_tenant.handlers.import_%s' % name,
)
signals.post_delete.connect(
handler.delete_handler,
sender=model,
dispatch_uid='openstack_tenant.handlers.delete_%s' % name,
)
signals.post_save.connect(
handlers.
sync_security_group_rule_property_when_resource_is_updated_or_created,
sender=SecurityGroupRule,
dispatch_uid='openstack_tenant.handlers.'
'sync_security_group_rule_property_when_resource_is_updated_or_created',
)
signals.post_delete.connect(
handlers.sync_security_group_rule_on_delete,
sender=SecurityGroupRule,
dispatch_uid=
'openstack_tenant.handlers.sync_security_group_rule_on_delete',
)
signals.post_save.connect(
handlers.log_backup_schedule_creation,
sender=models.BackupSchedule,
dispatch_uid=
'openstack_tenant.handlers.log_backup_schedule_creation',
)
signals.post_save.connect(
handlers.log_backup_schedule_action,
sender=models.BackupSchedule,
dispatch_uid='openstack_tenant.handlers.log_backup_schedule_action',
)
signals.pre_delete.connect(
handlers.log_backup_schedule_deletion,
sender=models.BackupSchedule,
dispatch_uid=
'openstack_tenant.handlers.log_backup_schedule_deletion',
)
signals.post_save.connect(
handlers.log_snapshot_schedule_creation,
sender=models.SnapshotSchedule,
dispatch_uid=
'openstack_tenant.handlers.log_snapshot_schedule_creation',
)
signals.post_save.connect(
handlers.log_snapshot_schedule_action,
sender=models.SnapshotSchedule,
dispatch_uid=
'openstack_tenant.handlers.log_snapshot_schedule_action',
)
signals.pre_delete.connect(
handlers.log_snapshot_schedule_deletion,
sender=models.SnapshotSchedule,
dispatch_uid=
'openstack_tenant.handlers.log_snapshot_schedule_deletion',
)
signals.post_save.connect(
handlers.update_service_settings_credentials,
sender=Tenant,
dispatch_uid=
'openstack_tenant.handlers.update_service_settings_credentials',
)
signals.post_save.connect(
handlers.update_service_settings,
sender=Tenant,
dispatch_uid='openstack_tenant.handlers.update_service_settings',
)
fsm_signals.post_transition.connect(
handlers.mark_private_settings_as_erred_if_tenant_creation_failed,
sender=Tenant,
dispatch_uid=
'openstack_tenant.handlers.mark_private_settings_as_erred_if_tenant_creation_failed',
)
signals.post_save.connect(
handlers.
copy_flavor_exclude_regex_to_openstacktenant_service_settings,
sender=ServiceSettings,
dispatch_uid='openstack_tenant.handlers.'
'copy_flavor_exclude_regex_to_openstacktenant_service_settings',
)
for model in (SharedServiceSettings, ServiceSettings):
signals.post_save.connect(
handlers.copy_config_drive_to_openstacktenant_service_settings,
sender=model,
dispatch_uid='openstack_tenant.handlers.'
'copy_config_drive_to_openstacktenant_service_settings_%s' %
model.__class__,
)
signals.post_save.connect(
handlers.create_service_from_tenant,
sender=Tenant,
dispatch_uid='openstack_tenant.handlers.create_service_from_tenant',
)
def ready(self):
from waldur_core.quotas.fields import QuotaField, CounterQuotaField
from waldur_core.structure.registry import SupportedServices
from waldur_core.structure import models as structure_models
from waldur_core.structure import signals as structure_signals
from waldur_freeipa import models as freeipa_models
from .backend import SlurmBackend
from . import handlers, models, utils
SupportedServices.register_backend(SlurmBackend)
signals.post_save.connect(
handlers.process_user_creation,
sender=freeipa_models.Profile,
dispatch_uid='waldur_slurm.handlers.process_user_creation',
)
signals.pre_delete.connect(
handlers.process_user_deletion,
sender=freeipa_models.Profile,
dispatch_uid='waldur_slurm.handlers.process_user_deletion',
)
structure_models_with_roles = (
structure_models.Customer,
structure_models.Project,
)
for model in structure_models_with_roles:
structure_signals.structure_role_granted.connect(
handlers.process_role_granted,
sender=model,
dispatch_uid='waldur_slurm.handlers.process_role_granted.%s' %
model.__class__,
)
structure_signals.structure_role_revoked.connect(
handlers.process_role_revoked,
sender=model,
dispatch_uid='waldur_slurm.handlers.process_role_revoked.%s' %
model.__class__,
)
for quota in utils.QUOTA_NAMES:
structure_models.Customer.add_quota_field(
name=quota, quota_field=QuotaField(is_backend=True))
structure_models.Project.add_quota_field(
name=quota, quota_field=QuotaField(is_backend=True))
structure_models.Project.add_quota_field(
name='nc_allocation_count',
quota_field=CounterQuotaField(
target_models=lambda: [models.Allocation],
path_to_scope='project',
),
)
structure_models.Customer.add_quota_field(
name='nc_allocation_count',
quota_field=CounterQuotaField(
target_models=lambda: [models.Allocation],
path_to_scope='project.customer',
),
)
signals.post_save.connect(
handlers.update_quotas_on_allocation_usage_update,
sender=models.Allocation,
dispatch_uid=
'waldur_slurm.handlers.update_quotas_on_allocation_usage_update',
)
def ready(self):
from waldur_core.structure.registry import SupportedServices
from .backend import DigitalOceanBackend
SupportedServices.register_backend(DigitalOceanBackend)
def ready(self):
from waldur_core.core import models as core_models
from waldur_core.quotas.fields import QuotaField
from waldur_core.structure import models as structure_models
from waldur_core.structure import signals as structure_signals
from waldur_core.structure.registry import SupportedServices
from . import handlers
Tenant = self.get_model('Tenant')
Network = self.get_model('Network')
SubNet = self.get_model('SubNet')
SecurityGroup = self.get_model('SecurityGroup')
SecurityGroupRule = self.get_model('SecurityGroupRule')
# structure
from .backend import OpenStackBackend
SupportedServices.register_backend(OpenStackBackend)
from . import quotas
quotas.inject_tenant_quotas()
for resource in ('vcpu', 'ram', 'storage'):
structure_models.ServiceSettings.add_quota_field(
name='openstack_%s' % resource,
quota_field=QuotaField(
creation_condition=lambda service_settings:
service_settings.type == OpenStackConfig.service_name),
)
for model in (structure_models.Project, structure_models.Customer):
structure_signals.structure_role_revoked.connect(
handlers.remove_ssh_key_from_tenants,
sender=model,
dispatch_uid=
'openstack.handlers.remove_ssh_key_from_tenants__%s' %
model.__name__,
)
signals.pre_delete.connect(
handlers.remove_ssh_key_from_all_tenants_on_it_deletion,
sender=core_models.SshPublicKey,
dispatch_uid=
'openstack.handlers.remove_ssh_key_from_all_tenants_on_it_deletion',
)
from waldur_core.quotas.models import Quota
signals.post_save.connect(
handlers.log_tenant_quota_update,
sender=Quota,
dispatch_uid='openstack.handlers.log_tenant_quota_update',
)
signals.post_save.connect(
handlers.update_service_settings_name,
sender=Tenant,
dispatch_uid='openstack.handlers.update_service_settings_name',
)
signals.post_delete.connect(
handlers.log_security_group_cleaned,
sender=SecurityGroup,
dispatch_uid='openstack.handlers.log_security_group_cleaned',
)
signals.post_delete.connect(
handlers.log_security_group_rule_cleaned,
sender=SecurityGroupRule,
dispatch_uid='openstack.handlers.log_security_group_rule_cleaned',
)
signals.post_delete.connect(
handlers.log_network_cleaned,
sender=Network,
dispatch_uid='openstack.handlers.log_network_cleaned',
)
signals.post_delete.connect(
handlers.log_subnet_cleaned,
sender=SubNet,
dispatch_uid='openstack.handlers.log_subnet_cleaned',
)
def test_get_service_backend(self):
self.assertEqual(
TestBackend,
SupportedServices.get_service_backend(TestConfig.service_name))