def debit_customers():
""" Fetch a list of shared services (services based on shared settings).
Calculate the amount of consumed resources "yesterday" (make sure this task executed only once a day)
Reduce customer's balance accordingly
Stop online resource if needed
"""
date = datetime.now() - timedelta(days=1)
start_date = date.replace(hour=0, minute=0, second=0, microsecond=0)
end_date = start_date + timedelta(days=1, microseconds=-1)
# XXX: it's just a placeholder, it doesn't work properly now nor implemented anyhow
# perhaps it should merely use price estimates..
# TODO: remove once iaas has been deprecated
from nodeconductor.iaas.models import Instance
models = filter(lambda model: model != Instance,
SupportedServices.get_resource_models().values())
for model in models:
resources = model.objects.filter(
service_project_link__service__settings__shared=True)
for resource in resources:
try:
data = resource.get_cost(start_date, end_date)
except NotImplementedError:
continue
else:
resource.customer.debit_account(data['total_amount'])
def _get_erred_resources_module(self):
"""
Returns a list of links to resources which are in ERRED state and linked to a shared service settings.
"""
result_module = modules.LinkList(title=_('Resources in erred state'))
erred_state = structure_models.NewResource.States.ERRED
children = []
resource_models = SupportedServices.get_resource_models()
resources_in_erred_state_overall = 0
for resource_type, resource_model in resource_models.items():
queryset = resource_model.objects.filter(
service_project_link__service__settings__shared=True)
erred_amount = queryset.filter(state=erred_state).count()
if erred_amount:
resources_in_erred_state_overall = resources_in_erred_state_overall + erred_amount
link = self._get_erred_resource_link(resource_model,
erred_amount, erred_state)
children.append(link)
if resources_in_erred_state_overall:
result_module.title = '%s (%s)' % (
result_module.title, resources_in_erred_state_overall)
result_module.children = children
else:
result_module.pre_content = _('Nothing found.')
return result_module
def queryset(self, request, queryset):
if self.value():
model = SupportedServices.get_resource_models().get(
self.value(), None)
if model:
return queryset.filter(resource_content_type=ContentType.
objects.get_for_model(model))
return queryset
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, ResourceTypeFilter):
return ' | '.join([
'"%s"' % f for f in SupportedServices.get_resource_models().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 filter(self, qs, value):
if value in EMPTY_VALUES:
return qs
resource_models = SupportedServices.get_resource_models()
try:
model = resource_models[value]
ct = ContentType.objects.get_for_model(model)
return super(ResourceTypeFilter, self).filter(qs, ct)
except (ContentType.DoesNotExist, KeyError):
return qs.none()
def lookups(self, request, model_admin):
resources = [
(model, name)
for name, model in SupportedServices.get_resource_models().items()
]
others = [(model, model.__name__)
for model in models.PriceEstimate.get_estimated_models()
if not issubclass(model, structure_models.ResourceMixin)]
estimated_models = [(core_utils.serialize_class(model), name)
for model, name in resources + others]
return sorted(estimated_models, key=lambda x: x[1])
def init_resource_count_quota(self):
self.stdout.write('Drop current nc_resource_count quotas values ...')
customer_ct = ContentType.objects.get_for_model(models.Customer)
project_ct = ContentType.objects.get_for_model(models.Project)
quotas_models.Quota.objects.filter(
name='nc_resource_count',
content_type__in=[project_ct, customer_ct]).update(usage=0)
self.stdout.write('... Done')
self.stdout.write(
'Calculating new nc_resource_count quotas values ...')
resource_models = SupportedServices.get_resource_models().values()
for model in resource_models:
for resource in model.objects.all():
resource.service_project_link.project.add_quota_usage(
'nc_resource_count', 1)
self.stdout.write('... Done')
def stop_customer_resources(customer_uuid):
if not settings.NODECONDUCTOR.get('SUSPEND_UNPAID_CUSTOMERS'):
return
customer = models.Customer.objects.get(uuid=customer_uuid)
for model_name, model in SupportedServices.get_resource_models().items():
# Shutdown active resources for debtors
# TODO: Consider supporting another states (like 'STARTING')
# TODO: Remove IaaS support (NC-645)
if model_name == 'IaaS.Instance':
resources = model.objects.filter(
state=model.States.ONLINE,
cloud_project_membership__cloud__customer=customer)
else:
resources = model.objects.filter(
state=model.States.ONLINE,
service_project_link__service__customer=customer)
for resource in resources:
try:
backend = resource.get_backend()
backend.stop()
except NotImplementedError:
continue
def lookups(self, request, model_admin):
return [
(name, name)
for name, model in SupportedServices.get_resource_models().items()
if model in CostTrackingRegister.registered_resources
]
def lookups(self, request, model_admin):
return [(k, k) for k in SupportedServices.get_resource_models().keys()]
