337 lines
13 KiB
Python
337 lines
13 KiB
Python
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.apps import apps
|
|
from django.db import models
|
|
from django.utils import timezone
|
|
from django.utils.functional import cached_property
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from djcelery.models import PeriodicTask
|
|
|
|
from orchestra.core import validators
|
|
from orchestra.models import queryset, fields
|
|
from orchestra.models.utils import get_model_field_path
|
|
|
|
from . import tasks
|
|
from .backends import ServiceMonitor
|
|
from .aggregations import Aggregation
|
|
from .validators import validate_scale
|
|
|
|
|
|
class ResourceQuerySet(models.QuerySet):
|
|
group_by = queryset.group_by
|
|
|
|
|
|
class Resource(models.Model):
|
|
"""
|
|
Defines a resource, a resource is basically an interpretation of data
|
|
gathered by a Monitor
|
|
"""
|
|
|
|
LAST = 'LAST'
|
|
MONTHLY_SUM = 'MONTHLY_SUM'
|
|
MONTHLY_AVG = 'MONTHLY_AVG'
|
|
PERIODS = (
|
|
(LAST, _("Last")),
|
|
(MONTHLY_SUM, _("Monthly sum")),
|
|
(MONTHLY_AVG, _("Monthly avg")),
|
|
)
|
|
_related = set() # keeps track of related models for resource cleanup
|
|
|
|
name = models.CharField(_("name"), max_length=32,
|
|
help_text=_("Required. 32 characters or fewer. Lowercase letters, "
|
|
"digits and hyphen only."),
|
|
validators=[validators.validate_name])
|
|
verbose_name = models.CharField(_("verbose name"), max_length=256)
|
|
content_type = models.ForeignKey(ContentType,
|
|
help_text=_("Model where this resource will be hooked."))
|
|
aggregation = models.CharField(_("aggregation"), max_length=16,
|
|
choices=Aggregation.get_choices(), default=Aggregation.get_choices()[0][0],
|
|
help_text=_("Method used for aggregating this resource monitored data."))
|
|
on_demand = models.BooleanField(_("on demand"), default=False,
|
|
help_text=_("If enabled the resource will not be pre-allocated, "
|
|
"but allocated under the application demand"))
|
|
default_allocation = models.PositiveIntegerField(_("default allocation"),
|
|
null=True, blank=True,
|
|
help_text=_("Default allocation value used when this is not an "
|
|
"on demand resource"))
|
|
unit = models.CharField(_("unit"), max_length=16,
|
|
help_text=_("The unit in which this resource is represented. "
|
|
"For example GB, KB or subscribers"))
|
|
scale = models.CharField(_("scale"), max_length=32, validators=[validate_scale],
|
|
help_text=_("Scale in which this resource monitoring resoults should "
|
|
"be prorcessed to match with unit. e.g. <tt>10**9</tt>"))
|
|
disable_trigger = models.BooleanField(_("disable trigger"), default=False,
|
|
help_text=_("Disables monitors exeeded and recovery triggers"))
|
|
crontab = models.ForeignKey('djcelery.CrontabSchedule', verbose_name=_("crontab"),
|
|
null=True, blank=True,
|
|
help_text=_("Crontab for periodic execution. "
|
|
"Leave it empty to disable periodic monitoring"))
|
|
monitors = fields.MultiSelectField(_("monitors"), max_length=256, blank=True,
|
|
choices=ServiceMonitor.get_choices(),
|
|
help_text=_("Monitor backends used for monitoring this resource."))
|
|
is_active = models.BooleanField(_("active"), default=True)
|
|
|
|
objects = ResourceQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
unique_together = (
|
|
('name', 'content_type'),
|
|
('verbose_name', 'content_type')
|
|
)
|
|
|
|
def __str__(self):
|
|
return "{}-{}".format(str(self.content_type), self.name)
|
|
|
|
@cached_property
|
|
def aggregation_class(self):
|
|
return Aggregation.get(self.aggregation)
|
|
|
|
@cached_property
|
|
def aggregation_instance(self):
|
|
""" Per request lived type_instance """
|
|
return self.aggregation_class(self)
|
|
|
|
def clean(self):
|
|
self.verbose_name = self.verbose_name.strip()
|
|
if self.on_demand and self.default_allocation:
|
|
raise validators.ValidationError({
|
|
'default_allocation': _("Default allocation can not be set for 'on demand' services")
|
|
})
|
|
# Validate that model path exists between ct and each monitor.model
|
|
monitor_errors = []
|
|
for monitor in self.monitors:
|
|
try:
|
|
self.get_model_path(monitor)
|
|
except (RuntimeError, LookupError):
|
|
model = apps.get_model(ServiceMonitor.get_backend(monitor).model)
|
|
monitor_errors.append(model._meta.model_name)
|
|
if monitor_errors:
|
|
model_name = self.content_type.model_class()._meta.model_name
|
|
raise validators.ValidationError({
|
|
'monitors': [
|
|
_("Path does not exists between '%s' and '%s'") % (
|
|
error,
|
|
model_name,
|
|
) for error in monitor_errors
|
|
]})
|
|
|
|
def save(self, *args, **kwargs):
|
|
created = not self.pk
|
|
super(Resource, self).save(*args, **kwargs)
|
|
self.sync_periodic_task()
|
|
# This only works on tests (multiprocessing used on real deployments)
|
|
apps.get_app_config('resources').reload_relations()
|
|
|
|
def delete(self, *args, **kwargs):
|
|
super(Resource, self).delete(*args, **kwargs)
|
|
self.sync_periodic_task()
|
|
|
|
def sync_periodic_task(self):
|
|
name = 'monitor.%s' % str(self)
|
|
if self.pk and self.crontab:
|
|
try:
|
|
task = PeriodicTask.objects.get(name=name)
|
|
except PeriodicTask.DoesNotExist:
|
|
if self.is_active:
|
|
PeriodicTask.objects.create(
|
|
name=name,
|
|
task='resources.Monitor',
|
|
args=[self.pk],
|
|
crontab=self.crontab
|
|
)
|
|
else:
|
|
if task.crontab != self.crontab:
|
|
task.crontab = self.crontab
|
|
task.save(update_fields=['crontab'])
|
|
else:
|
|
PeriodicTask.objects.filter(name=name).delete()
|
|
|
|
def get_model_path(self, monitor):
|
|
""" returns a model path between self.content_type and monitor.model """
|
|
resource_model = self.content_type.model_class()
|
|
monitor_model = ServiceMonitor.get_backend(monitor).model_class()
|
|
return get_model_field_path(monitor_model, resource_model)
|
|
|
|
def get_scale(self):
|
|
return eval(self.scale)
|
|
|
|
def get_verbose_name(self):
|
|
return self.verbose_name or self.name
|
|
|
|
def monitor(self, async=True):
|
|
if async:
|
|
return tasks.monitor.apply_async(self.pk)
|
|
return tasks.monitor(self.pk)
|
|
|
|
|
|
class ResourceData(models.Model):
|
|
""" Stores computed resource usage and allocation """
|
|
resource = models.ForeignKey(Resource, related_name='dataset', verbose_name=_("resource"))
|
|
content_type = models.ForeignKey(ContentType, verbose_name=_("content type"))
|
|
object_id = models.PositiveIntegerField(_("object id"))
|
|
used = models.DecimalField(_("used"), max_digits=16, decimal_places=3, null=True,
|
|
editable=False)
|
|
updated_at = models.DateTimeField(_("updated"), null=True, editable=False)
|
|
allocated = models.DecimalField(_("allocated"), max_digits=8, decimal_places=2,
|
|
null=True, blank=True)
|
|
|
|
content_object = GenericForeignKey()
|
|
|
|
class Meta:
|
|
unique_together = ('resource', 'content_type', 'object_id')
|
|
verbose_name_plural = _("resource data")
|
|
|
|
def __str__(self):
|
|
return "%s: %s" % (str(self.resource), str(self.content_object))
|
|
|
|
@classmethod
|
|
def get_or_create(cls, obj, resource):
|
|
ct = ContentType.objects.get_for_model(type(obj))
|
|
try:
|
|
return cls.objects.get(
|
|
content_type=ct,
|
|
object_id=obj.pk,
|
|
resource=resource
|
|
), False
|
|
except cls.DoesNotExist:
|
|
return cls.objects.create(
|
|
content_object=obj,
|
|
resource=resource,
|
|
allocated=resource.default_allocation
|
|
), True
|
|
|
|
@property
|
|
def unit(self):
|
|
return self.resource.unit
|
|
|
|
def get_used(self):
|
|
resource = self.resource
|
|
total = 0
|
|
has_result = False
|
|
for dataset in self.get_monitor_datasets():
|
|
dataset = resource.aggregation_instance.filter(dataset)
|
|
usage = resource.aggregation_instance.compute_usage(dataset)
|
|
if usage is not None:
|
|
has_result = True
|
|
total += usage
|
|
return float(total)/resource.get_scale() if has_result else None
|
|
|
|
def update(self, current=None):
|
|
if current is None:
|
|
current = self.get_used()
|
|
self.used = current or 0
|
|
self.updated_at = timezone.now()
|
|
self.save(update_fields=['used', 'updated_at'])
|
|
|
|
def monitor(self, async=False):
|
|
ids = (self.object_id,)
|
|
if async:
|
|
return tasks.monitor.delay(self.resource_id, ids=ids)
|
|
return tasks.monitor(self.resource_id, ids=ids)
|
|
|
|
def get_monitor_datasets(self):
|
|
resource = self.resource
|
|
datasets = []
|
|
for monitor in resource.monitors:
|
|
path = resource.get_model_path(monitor)
|
|
if path == []:
|
|
dataset = MonitorData.objects.filter(
|
|
monitor=monitor,
|
|
content_type=self.content_type_id,
|
|
object_id=self.object_id,
|
|
)
|
|
else:
|
|
fields = '__'.join(path)
|
|
monitor_model = ServiceMonitor.get_backend(monitor).model_class()
|
|
objects = monitor_model.objects.filter(**{fields: self.object_id})
|
|
pks = objects.values_list('id', flat=True)
|
|
ct = ContentType.objects.get_for_model(monitor_model)
|
|
dataset = MonitorData.objects.filter(
|
|
monitor=monitor,
|
|
content_type=ct,
|
|
object_id__in=pks,
|
|
)
|
|
datasets.append(dataset)
|
|
return datasets
|
|
|
|
|
|
class MonitorDataQuerySet(models.QuerySet):
|
|
group_by = queryset.group_by
|
|
|
|
|
|
class MonitorData(models.Model):
|
|
""" Stores monitored data """
|
|
monitor = models.CharField(_("monitor"), max_length=256,
|
|
choices=ServiceMonitor.get_choices())
|
|
content_type = models.ForeignKey(ContentType, verbose_name=_("content type"))
|
|
object_id = models.PositiveIntegerField(_("object id"))
|
|
created_at = models.DateTimeField(_("created"), default=timezone.now)
|
|
value = models.DecimalField(_("value"), max_digits=16, decimal_places=2)
|
|
|
|
content_object = GenericForeignKey()
|
|
objects = MonitorDataQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
get_latest_by = 'id'
|
|
verbose_name_plural = _("monitor data")
|
|
|
|
def __str__(self):
|
|
return str(self.monitor)
|
|
|
|
@cached_property
|
|
def unit(self):
|
|
return self.resource.unit
|
|
|
|
|
|
def create_resource_relation():
|
|
class ResourceHandler(object):
|
|
""" account.resources.web """
|
|
def __getattr__(self, attr):
|
|
""" get or build ResourceData """
|
|
try:
|
|
return self.obj.__resource_cache[attr]
|
|
except AttributeError:
|
|
self.obj.__resource_cache = {}
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
data = self.obj.resource_set.get(resource__name=attr)
|
|
except ResourceData.DoesNotExist:
|
|
model = self.obj._meta.model_name
|
|
resource = Resource.objects.get(
|
|
content_type__model=model,
|
|
name=attr,
|
|
is_active=True
|
|
)
|
|
data = ResourceData(
|
|
content_object=self.obj,
|
|
resource=resource,
|
|
allocated=resource.default_allocation
|
|
)
|
|
self.obj.__resource_cache[attr] = data
|
|
return data
|
|
|
|
def __get__(self, obj, cls):
|
|
""" proxy handled object """
|
|
self.obj = obj
|
|
return self
|
|
|
|
# Clean previous state
|
|
for related in Resource._related:
|
|
try:
|
|
delattr(related, 'resource_set')
|
|
delattr(related, 'resources')
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
related._meta.virtual_fields = [
|
|
field for field in related._meta.virtual_fields if field.rel.to != ResourceData
|
|
]
|
|
|
|
for ct, resources in Resource.objects.group_by('content_type').items():
|
|
model = ct.model_class()
|
|
relation = GenericRelation('resources.ResourceData')
|
|
model.add_to_class('resource_set', relation)
|
|
model.resources = ResourceHandler()
|
|
Resource._related.add(model)
|