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