qcg/models.py

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