X-Git-Url: http://mmka.chem.univ.gda.pl/gitweb/?a=blobdiff_plain;f=qcg%2Fmodels.py;h=6c25e3bb1b9e3f69ba77db57949fedece1c03388;hb=b9bcd422c66e0cd9b0f20a0c037dbc2d811bb59f;hp=71a836239075aa6e6e4ecb700e9c42c95c022d91;hpb=0abdf2f7af1798b74d6e1148e5e322af5c708eb6;p=qcg-portal.git

diff --git a/qcg/models.py b/qcg/models.py
index 71a8362..6c25e3b 100644
--- a/qcg/models.py
+++ b/qcg/models.py
@@ -1,3 +1,232 @@
+# coding=utf-8
+from django.contrib.auth.models import AbstractUser
+from django.core.urlresolvers import reverse
 from django.db import models
+from django.utils.timezone import now
+from pyqcg.service import Job as QcgJob, Task as QcgTask
+from pyqcg.utils import JobStatus, TaskStatus, TaskType
+from timedelta import TimedeltaField
 
-# Create your models here.
+from qcg.utils import username_from_dn, get_attributes
+
+
+__all__ = ['User', 'Job', 'Task', 'Allocation', 'NodeInfo']
+
+
+class User(AbstractUser):
+    last_update = models.DateTimeField(default=now)
+
+    @property
+    def tasks(self):
+        return Task.objects.filter(job__owner=self)
+
+
+class Job(models.Model):
+    STATUS_CHOICES = list(enumerate(field for field in dir(JobStatus) if not field.startswith('__')))
+    STATUS_CHOICES_REVERSED = {v: k for k, v in STATUS_CHOICES}
+
+    _job = None
+
+    epr = models.TextField(u"Endpoint reference")
+    job_id = models.TextField(u"Identyfikator", unique=True)
+    status = models.IntegerField(u"Status", choices=STATUS_CHOICES)
+    note = models.TextField(u"Notatka", blank=True, default='')
+    description = models.TextField(u"Opis", blank=True, default='')
+    project = models.TextField(u"Projekt", blank=True, default='')
+    submission_time = models.DateTimeField(u"Data wysłania")
+    finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
+    proxy_lifetime = TimedeltaField(u"Czas życia proxy", blank=True, null=True)
+    purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
+
+    owner = models.ForeignKey(User, verbose_name=u"Właściciel", related_name='jobs')
+    created = models.DateTimeField(u"Utworzono", auto_now_add=True)
+    updated = models.DateTimeField(u"Uaktualniono", auto_now=True)
+
+    class Meta:
+        # verbose_name = u"Zadanie"
+        # verbose_name_plural = u"Zadania"
+        ordering = ('-submission_time',)
+
+    def __unicode__(self):
+        return self.job_id
+
+    def get_absolute_url(self):
+        return reverse('job', kwargs={'job_id': self.job_id})
+
+    @property
+    def qcg_job(self):
+        if self._job is None:
+            self._job = QcgJob(self.epr)
+
+        return self._job
+
+    @staticmethod
+    def qcg_map(qcg_job, user=None):
+        attrs = get_attributes(qcg_job, ('job_id', 'note', 'description', 'submission_time', 'finish_time',
+                                         'proxy_lifetime', 'project', 'purged'))
+
+        attrs['epr'] = str(qcg_job.epr)
+        attrs['status'] = Job.STATUS_CHOICES_REVERSED[qcg_job.status]
+
+        username = username_from_dn(qcg_job.user_dn)
+        if user is not None:
+            if user.username != username:
+                raise ValueError('')
+            attrs['owner'] = user
+        else:
+            attrs['owner'] = User.objects.get(username=username)
+
+        return attrs
+
+    @classmethod
+    def from_qcg(cls, qcg_job):
+        job = cls(**cls.qcg_map(qcg_job))
+        job._job = qcg_job
+
+        return job
+
+
+class Task(models.Model):
+    STATUS_CHOICES = list(enumerate(field for field in dir(TaskStatus) if not field.startswith('__')))
+    STATUS_CHOICES_REVERSED = {v: k for k, v in STATUS_CHOICES}
+    TYPE_CHOICES = list(enumerate(field for field in dir(TaskType) if not field.startswith('__')))
+    TYPE_CHOICES_REVERSED = {v: k for k, v in TYPE_CHOICES}
+
+    _task = None
+
+    job = models.ForeignKey(Job, verbose_name=u"Zadanie", related_name='tasks')
+
+    epr = models.TextField(u"Endpoint reference")
+    task_id = models.TextField(u"Identyfikator", db_index=True)
+    status = models.IntegerField(u"Status", choices=STATUS_CHOICES)
+    status_description = models.TextField(u"Opis statusu", blank=True, default='')
+    type = models.IntegerField(u"Typ", choices=TYPE_CHOICES)
+    note = models.TextField(u"Notatka", blank=True, default='')
+    description = models.TextField(u"Opis", blank=True, default='')
+    submission_time = models.DateTimeField(u"Data wysłania")
+    start_time = models.DateTimeField(u"Data rozpoczęcia", blank=True, null=True)
+    finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
+    reserved_time_start = models.DateTimeField(u"Data rozpoczęcia rezerwacji", blank=True, null=True)
+    reserved_time_finish = models.DateTimeField(u"Data zakończenia rezerwacji", blank=True, null=True)
+    proxy_lifetime = TimedeltaField(u"Czas życia proxy", blank=True, null=True)
+    purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
+
+    created = models.DateTimeField(u"Utworzono", auto_now_add=True)
+    updated = models.DateTimeField(u"Uaktualniono", auto_now=True)
+
+    class Meta:
+        # verbose_name = u"Zadanie"
+        # verbose_name_plural = u"Zadania"
+        ordering = ('-submission_time',)
+        unique_together = ('job', 'task_id')
+
+    def __unicode__(self):
+        return u'{}/{}'.format(self.job, self.task_id)
+
+    def get_absolute_url(self):
+        return reverse('task', kwargs={'job_id': self.job.job_id, 'task_id': self.task_id})
+
+    @property
+    def qcg_task(self):
+        if self._qcg_task is None:
+            self._qcg_task = QcgTask(self.epr)
+
+        return self._qcg_task
+
+    @staticmethod
+    def qcg_map(qcg_task, jobs=None):
+        attrs = get_attributes(qcg_task, ('task_id', 'status_description', 'note', 'description', 'submission_time',
+                                          'start_time', 'finish_time', 'reserved_time_slot', 'proxy_lifetime',
+                                          'purged'))
+
+        attrs['epr'] = str(qcg_task.epr)
+        attrs['status'] = Task.STATUS_CHOICES_REVERSED[qcg_task.status]
+        attrs['type'] = Task.TYPE_CHOICES_REVERSED[qcg_task.type]
+
+        if jobs is not None and qcg_task.job_id in jobs:
+            attrs['job'] = jobs[qcg_task.job_id]
+        else:
+            attrs['job'] = Job.objects.get(job_id=qcg_task.job_id)
+
+        return attrs
+
+    @classmethod
+    def from_qcg(cls, qcg_task):
+        task = cls(**cls.qcg_map(qcg_task))
+        task._task = qcg_task
+
+        return task
+
+    @property
+    def reserved_time_slot(self):
+        if self.reserved_time_start or self.reserved_time_finish:
+            return self.reserved_time_start, self.reserved_time_finish
+
+    @reserved_time_slot.setter
+    def reserved_time_slot(self, value):
+        if value is not None:
+            self.reserved_time_start, self.reserved_time_finish = value
+
+    @property
+    def hosts(self):
+        return {alloc.host_name for alloc in self.allocations.all()}
+
+
+class Allocation(models.Model):
+    task = models.ForeignKey(Task, verbose_name='Zadanie', related_name='allocations')
+
+    host_name = models.CharField(u"Host", max_length=100)
+    status_description = models.TextField(u"Opis statusu", blank=True, default='')
+    processes_count = models.PositiveIntegerField(u"Liczba procesorów")
+    slots_count = models.PositiveIntegerField(u"Liczba slotów")
+    processes_group_id = models.TextField(u"Identyfikator grupy procesów", blank=True, default='')
+    submission_time = models.DateTimeField(u"Data wysłania")
+    estimated_start_time = models.DateTimeField(u"Przewidywana data rozpoczęcia", blank=True, null=True)
+    finish_time = models.DateTimeField(u"Data zakończenia", blank=True, null=True)
+    local_submission_time = models.DateTimeField(u"Lokalna data wysłania", blank=True, null=True)
+    local_start_time = models.DateTimeField(u"Lokalna data rozpoczęcia", blank=True, null=True)
+    local_finish_time = models.DateTimeField(u"Lokalna data zakończenia", blank=True, null=True)
+    purged = models.BooleanField(u"Usunięty katalog roboczy?", default=False)
+    efficiency = models.IntegerField(u"Efektywność", blank=True, null=True)  # ??
+    comment = models.TextField(u"Komentarz", blank=True, default='')
+    memory_usage = models.PositiveIntegerField(u"Użycie pamięci", blank=True, null=True)
+
+    class Meta:
+        verbose_name = u"Alokacja"
+        verbose_name_plural = u"Alokacje"
+        ordering = ('-submission_time',)
+
+    def __unicode__(self):
+        return u'{} @ {}'.format(self.task, self.host_name)
+
+    @staticmethod
+    def qcg_map(qcg_allocation):
+        return get_attributes(qcg_allocation, ('host_name', 'status_description', 'processes_count', 'slots_count',
+                                               'processes_group_id', 'submission_time', 'estimated_start_time',
+                                               'finish_time', 'local_submission_time', 'local_start_time',
+                                               'local_finish_time', 'purged', 'efficiency', 'comment', 'memory_usage'))
+
+
+class NodeInfo(models.Model):
+    allocation = models.ForeignKey(Allocation, verbose_name=u"Alokacja", related_name='nodes')
+
+    name = models.CharField(u"Nazwa", max_length=32)
+    count = models.PositiveSmallIntegerField(u"Liczba slotów", blank=True, null=True)
+
+    class Meta:
+        verbose_name = u"Węzeł"
+        verbose_name_plural = u"Węzły"
+
+    def __unicode__(self):
+        result = u'{} - {}'.format(self.allocation, self.name)
+
+        if self.count is not None:
+            result += u' ({})'.format(self.count)
+
+        return result
+
+    @staticmethod
+    def qcg_map(qcg_node):
+        return {'name': qcg_node.value,
+                # FIXME
+                'count': qcg_node.slots_count.intValue() if qcg_node.slots_count is not None else None}