qcg/models.py

   1 # coding=utf-8
   2 from django.contrib.auth.models import AbstractUser
   3 from django.core.urlresolvers import reverse
   4 from django.db import models
   5 from django.utils.timezone import now
   6 from pyqcg.service import Job as QcgJob, Task as QcgTask
   7 from pyqcg.utils import JobStatus, TaskStatus, TaskType, AllocationType, EPRUtils, DescriptionType
   8
   9 from qcg.utils import username_from_dn, get_attributes
  10
  11
  12 __all__ = ['User', 'Job', 'Task', 'Allocation', 'NodeInfo', 'JobTemplate']
  13
  14
  15 class User(AbstractUser):
  16     last_update = models.DateTimeField(default=now)
  17
  18     @property
  19     def tasks(self):
  20         return Task.objects.filter(job__owner=self)
  21
  22
  23 DESC_TYPE_CHOICES = list(enumerate(field for field in dir(DescriptionType) if not field.startswith('__')))
  24 DESC_TYPE_CHOICES_REVERSED = {v: k for k, v in DESC_TYPE_CHOICES}
  25
  26
  27 class Job(models.Model):
  28     STATUS_CHOICES = list(enumerate(field for field in dir(JobStatus) if not field.startswith('__')))
  29     STATUS_CHOICES_REVERSED = {v: k for k, v in STATUS_CHOICES}
  30
  31     _job = None
  32
  33     epr = models.TextField(u"Endpoint reference")
  34     job_id = models.TextField(u"Identyfikator", unique=True)
  35     status = models.IntegerField(u"Status", choices=STATUS_CHOICES)
  36     note = models.TextField(u"Notatka", blank=True, default='')
  37     description = models.TextField(u"Opis", blank=True, default='')
  38     description_type = models.IntegerField(u"Typ opisu", choices=DESC_TYPE_CHOICES, blank=True, null=True)
  39     qcg_description = models.TextField(u"Opis QCG", blank=True, default='')
  40     project = models.TextField(u"Projekt", blank=True, default='')
  41     submission_time = models.DateTimeField(u"Data wysłania")
  42     finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
  43     proxy_lifetime = models.DateTimeField(u"Czas życia proxy", blank=True, null=True)
  44     purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
  45
  46     owner = models.ForeignKey(User, verbose_name=u"Właściciel", related_name='jobs')
  47     created = models.DateTimeField(u"Utworzono", auto_now_add=True)
  48     updated = models.DateTimeField(u"Uaktualniono", auto_now=True)
  49
  50     class Meta:
  51         # verbose_name = u"Zadanie"
  52         # verbose_name_plural = u"Zadania"
  53         ordering = ('-submission_time',)
  54
  55     def __unicode__(self):
  56         return self.job_id
  57
  58     def get_absolute_url(self):
  59         return reverse('job', kwargs={'job_id': self.job_id})
  60
  61     @property
  62     def qcg_job(self):
  63         if self._job is None:
  64             self._job = QcgJob(EPRUtils.deserialize_epr(self.epr))
  65
  66         return self._job
  67
  68     @staticmethod
  69     def qcg_map(qcg_job, user=None):
  70         attrs = get_attributes(qcg_job, ('job_id', 'note', 'description', 'qcg_description', 'submission_time',
  71                                          'finish_time', 'project', 'purged'))
  72
  73         attrs['epr'] = EPRUtils.serialize_epr(qcg_job.epr)
  74         attrs['status'] = Job.STATUS_CHOICES_REVERSED[qcg_job.status]
  75         attrs['description_type'] = DESC_TYPE_CHOICES_REVERSED[qcg_job.description_type]
  76         attrs['proxy_lifetime'] = now() + qcg_job.proxy_lifetime
  77
  78         username = username_from_dn(qcg_job.user_dn)
  79         if user is not None:
  80             if user.username != username:
  81                 raise ValueError('Username does not match ({} vs. {})!'.format(repr(user.username), repr(username)))
  82             attrs['owner'] = user
  83         else:
  84             attrs['owner'] = User.objects.get(username=username)
  85
  86         return attrs
  87
  88     @property
  89     def terminated(self):
  90         return self.get_status_display() in [JobStatus.FINISHED, JobStatus.FAILED, JobStatus.CANCELED]
  91
  92
  93 class Task(models.Model):
  94     STATUS_CHOICES = list(enumerate(field for field in dir(TaskStatus) if not field.startswith('__')))
  95     STATUS_CHOICES_REVERSED = {v: k for k, v in STATUS_CHOICES}
  96     TYPE_CHOICES = list(enumerate(field for field in dir(TaskType) if not field.startswith('__')))
  97     TYPE_CHOICES_REVERSED = {v: k for k, v in TYPE_CHOICES}
  98
  99     _task = None
 100
 101     job = models.ForeignKey(Job, verbose_name=u"Zadanie", related_name='tasks')
 102
 103     epr = models.TextField(u"Endpoint reference")
 104     task_id = models.TextField(u"Identyfikator", db_index=True)
 105     status = models.IntegerField(u"Status", choices=STATUS_CHOICES)
 106     status_description = models.TextField(u"Opis statusu", blank=True, default='')
 107     type = models.IntegerField(u"Typ", choices=TYPE_CHOICES)
 108     note = models.TextField(u"Notatka", blank=True, default='')
 109     description = models.TextField(u"Opis", blank=True, default='')
 110     description_type = models.IntegerField(u"Typ opisu", choices=DESC_TYPE_CHOICES, blank=True, null=True)
 111     submission_time = models.DateTimeField(u"Data wysłania")
 112     start_time = models.DateTimeField(u"Data rozpoczęcia", blank=True, null=True)
 113     finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
 114     reserved_time_start = models.DateTimeField(u"Data rozpoczęcia rezerwacji", blank=True, null=True)
 115     reserved_time_finish = models.DateTimeField(u"Data zakończenia rezerwacji", blank=True, null=True)
 116     proxy_lifetime = models.DateTimeField(u"Czas życia proxy", blank=True, null=True)
 117     purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
 118
 119     created = models.DateTimeField(u"Utworzono", auto_now_add=True)
 120     updated = models.DateTimeField(u"Uaktualniono", auto_now=True)
 121
 122     class Meta:
 123         # verbose_name = u"Zadanie"
 124         # verbose_name_plural = u"Zadania"
 125         ordering = ('-submission_time',)
 126         unique_together = ('job', 'task_id')
 127
 128     def __unicode__(self):
 129         return u'{}/{}'.format(self.job, self.task_id)
 130
 131     def get_absolute_url(self):
 132         return reverse('task', kwargs={'job_id': self.job.job_id, 'task_id': self.task_id})
 133
 134     @property
 135     def qcg_task(self):
 136         if self._task is None:
 137             self._task = QcgTask(EPRUtils.deserialize_epr(self.epr))
 138
 139         return self._task
 140
 141     @staticmethod
 142     def qcg_map(qcg_task, job=None):
 143         attrs = get_attributes(qcg_task, ('task_id', 'status_description', 'note', 'description', 'submission_time',
 144                                           'start_time', 'finish_time', 'reserved_time_slot', 'purged'))
 145
 146         attrs['epr'] = EPRUtils.serialize_epr(qcg_task.epr)
 147         attrs['status'] = Task.STATUS_CHOICES_REVERSED[qcg_task.status]
 148         attrs['type'] = Task.TYPE_CHOICES_REVERSED[qcg_task.type]
 149         attrs['description_type'] = DESC_TYPE_CHOICES_REVERSED[qcg_task.description_type]
 150         attrs['proxy_lifetime'] = now() + qcg_task.proxy_lifetime
 151
 152         if job is not None:
 153             if qcg_task.job_id != job.job_id:
 154                 raise ValueError('Job id does not match ({} vs. {})!'.format(repr(qcg_task.job_id), repr(job.job_id)))
 155             attrs['job'] = job
 156         else:
 157             attrs['job'] = Job.objects.get(job_id=qcg_task.job_id)
 158
 159         return attrs
 160
 161     @property
 162     def reserved_time_slot(self):
 163         if self.reserved_time_start or self.reserved_time_finish:
 164             return self.reserved_time_start, self.reserved_time_finish
 165
 166     @reserved_time_slot.setter
 167     def reserved_time_slot(self, value):
 168         if value is not None:
 169             self.reserved_time_start, self.reserved_time_finish = value
 170
 171     @property
 172     def short_host_names(self):
 173         return {alloc.host_name.split('.', 1)[0] for alloc in self.allocations.all()}
 174
 175     @property
 176     def terminated(self):
 177         return self.get_status_display() in [TaskStatus.FINISHED, TaskStatus.FAILED, TaskStatus.CANCELED]
 178
 179
 180 class Allocation(models.Model):
 181     STATUS_CHOICES = list(enumerate(field for field in dir(AllocationType) if not field.startswith('__')))
 182     STATUS_CHOICES_REVERSED = {v: k for k, v in STATUS_CHOICES}
 183
 184     task = models.ForeignKey(Task, verbose_name='Zadanie', related_name='allocations')
 185
 186     host_name = models.CharField(u"Host", max_length=100)
 187     status = models.IntegerField(u"Status", choices=STATUS_CHOICES)
 188     status_description = models.TextField(u"Opis statusu", blank=True, default='')
 189     processes_count = models.PositiveIntegerField(u"Liczba procesów")
 190     slots_count = models.PositiveIntegerField(u"Liczba rdzeni")
 191     processes_group_id = models.TextField(u"Identyfikator grupy procesów", blank=True, default='')
 192     submission_time = models.DateTimeField(u"Data wysłania")
 193     estimated_start_time = models.DateTimeField(u"Przewidywana data rozpoczęcia", blank=True, null=True)
 194     finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
 195     local_submission_time = models.DateTimeField(u"Lokalna data wysłania", blank=True, null=True)
 196     local_start_time = models.DateTimeField(u"Lokalna data rozpoczęcia", blank=True, null=True)
 197     local_finish_time = models.DateTimeField(u"Lokalna data zakończenia", blank=True, null=True)
 198     purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
 199     efficiency = models.IntegerField(u"Efektywność", blank=True, null=True)  # ??
 200     comment = models.TextField(u"Komentarz", blank=True, default='')
 201     memory_usage = models.PositiveIntegerField(u"Użycie pamięci", blank=True, null=True)
 202     working_directory = models.CharField(u"Katalog roboczy", max_length=1024, blank=True, default='')
 203
 204     class Meta:
 205         verbose_name = u"Alokacja"
 206         verbose_name_plural = u"Alokacje"
 207         ordering = ('-submission_time',)
 208
 209     def __unicode__(self):
 210         return u'{} @ {}'.format(self.task, self.host_name)
 211
 212     @staticmethod
 213     def qcg_map(qcg_allocation):
 214         attrs = get_attributes(qcg_allocation, ('host_name', 'status_description', 'processes_count', 'slots_count',
 215                                                 'processes_group_id', 'submission_time', 'estimated_start_time',
 216                                                 'finish_time', 'local_submission_time', 'local_start_time',
 217                                                 'local_finish_time', 'purged', 'efficiency', 'comment', 'memory_usage',
 218                                                 'working_directory'))
 219
 220         attrs['status'] = Allocation.STATUS_CHOICES_REVERSED[qcg_allocation.status]
 221
 222         return attrs
 223
 224
 225 class NodeInfo(models.Model):
 226     allocation = models.ForeignKey(Allocation, verbose_name=u"Alokacja", related_name='nodes')
 227
 228     name = models.CharField(u"Nazwa", max_length=32)
 229     count = models.PositiveSmallIntegerField(u"Liczba rdzeni", blank=True, null=True)
 230
 231     class Meta:
 232         verbose_name = u"Węzeł"
 233         verbose_name_plural = u"Węzły"
 234
 235     def __unicode__(self):
 236         result = u'{} - {}'.format(self.allocation, self.name)
 237
 238         if self.count is not None:
 239             result += u' ({})'.format(self.count)
 240
 241         return result
 242
 243     @staticmethod
 244     def qcg_map(qcg_node):
 245         return {'name': qcg_node.name, 'count': qcg_node.slots_count}
 246
 247
 248 class JobTemplate(models.Model):
 249     name = models.CharField(u"Nazwa", max_length=100)
 250     description = models.TextField(u"Opis")
 251
 252     owner = models.ForeignKey(User, verbose_name=u"Właściciel", related_name='templates')
 253     created = models.DateTimeField(u"Utworzono", auto_now_add=True)
 254     updated = models.DateTimeField(u"Uaktualniono", auto_now=True)
 255
 256     class Meta:
 257         verbose_name = u"Szablon zadania"
 258         verbose_name_plural = u"Szablony zadania"
 259
 260     def __unicode__(self):
 261         return u"{} ({})".format(self.name, self.owner)
 262
 263     def get_absolute_url(self):
 264         return reverse('template_submit', kwargs={'template_id': self.id})