implement classes for tracking task status

gnuviechadmin/osusers/models.py

@@ -10,6 +10,8 @@ from django.utils.translation import ugettext as _
 
 from model_utils.models import TimeStampedModel
 
+from celery.result import AsyncResult
+
 from passlib.hash import sha512_crypt
 from passlib.utils import generate_password
 
@@ -23,6 +25,33 @@ from .tasks import (
 )
 
 
+class TaskResult(TimeStampedModel, models.Model):
+
+    task_uuid = models.CharField(primary_key=True, max_length=64, blank=False)
+    task_name = models.CharField(max_length=255, blank=False, db_index=True)
+    is_finished = models.BooleanField(default=False)
+    is_success = models.BooleanField(default=False)
+    state = models.CharField(max_length=10)
+    result_body = models.TextField(blank=True)
+
+    class Meta:
+        abstract = True
+
+    def _set_result_fields(self, asyncresult):
+        if asyncresult.ready():
+            self.is_finished = True
+            self.is_success = asyncresult.state == 'SUCCESS'
+            self.result_body = str(asyncresult.result)
+            self.state = asyncresult.state
+            asyncresult.get(no_ack=False)
+
+    def update_taskstatus(self):
+        if not self.is_finished:
+            asyncresult = AsyncResult(self.task_uuid, task_name=self.task_name)
+            self._set_result_fields(asyncresult)
+            self.save()
+
+
 class GroupManager(models.Manager):
 
     def get_next_gid(self):
@@ -53,14 +82,65 @@ class Group(TimeStampedModel, models.Model):
 
     def save(self, *args, **kwargs):
         super(Group, self).save(*args, **kwargs)
-        create_ldap_group.delay(self.groupname, self.gid, self.descr)
+        GroupTaskResult.objects.create_grouptaskresult(
+            self, create_ldap_group.delay(self.groupname, self.gid, self.descr)
+        )
         return self
 
     def delete(self, *args, **kwargs):
-        delete_ldap_group_if_empty.delay(self.groupname)
+        DeleteTaskResult.objects.create_deletetaskresult(
+            'group', self.groupname,
+            delete_ldap_group_if_empty.delay(self.groupname)
+        )
         super(Group, self).delete(*args, **kwargs)
 
 
+class TaskResultManager(models.Manager):
+
+    def create(self, asyncresult):
+        result = self.model(
+            task_uuid=asyncresult.task_id, task_name=asyncresult.task_name
+        )
+        result._set_result_fields(asyncresult)
+        return result
+
+
+class DeleteTaskResultManager(TaskResultManager):
+
+    def create_deletetaskresult(self, modeltype, modelname, asyncresult):
+        taskresult = super(DeleteTaskResultManager, self).create(
+            asyncresult)
+        taskresult.modeltype = modeltype
+        taskresult.modelname = modelname
+        taskresult.save()
+        return taskresult
+
+
+class DeleteTaskResult(TaskResult):
+
+    modeltype = models.CharField(max_length=20, db_index=True)
+    modelname = models.CharField(max_length=255)
+
+    objects = DeleteTaskResultManager()
+
+
+class GroupTaskResultManager(TaskResultManager):
+
+    def create_grouptaskresult(self, group, asyncresult, commit=False):
+        taskresult = super(GroupTaskResultManager, self).create(
+            asyncresult)
+        taskresult.group = group
+        taskresult.save()
+        return taskresult
+
+
+class GroupTaskResult(TaskResult):
+
+    group = models.ForeignKey(Group)
+
+    objects = GroupTaskResultManager()
+
+
 class UserManager(models.Manager):
 
     def get_next_uid(self):
@@ -94,7 +174,10 @@ class UserManager(models.Manager):
             password = generate_password()
         homedir = os.path.join(settings.OSUSER_HOME_BASEPATH, username)
         group = Group.objects.create(groupname=username, gid=gid)
-        create_ldap_group.delay(group.groupname, group.gid, group.descr)
+        GroupTaskResult.objects.create(
+            group,
+            create_ldap_group.delay(group.groupname, group.gid, group.descr)
+        )
         user = self.create(username=username, group=group, uid=uid,
                            homedir=homedir,
                            shell=settings.OSUSER_DEFAULT_SHELL)
@@ -126,15 +209,22 @@ class User(TimeStampedModel, models.Model):
         return '{0} ({1})'.format(self.username, self.uid)
 
     def set_password(self, password):
-        create_ldap_user.delay(
-            self.username, self.uid, self.group.id, self.gecos, self.homedir,
-            self.shell, password
+        UserTaskResult.objects.create_usertaskresult(
+            self,
+            create_ldap_user.delay(
+                self.username, self.uid, self.group.id, self.gecos,
+                self.homedir, self.shell, password
+            ),
+            commit=True
         )
 
     def save(self, *args, **kwargs):
-        create_ldap_user.delay(
-            self.username, self.uid, self.group.id, self.gecos, self.homedir,
-            self.shell, password=None
+        UserTaskResult.objects.create_usertaskresult(
+            self,
+            create_ldap_user.delay(
+                self.username, self.uid, self.group.id, self.gecos,
+                self.homedir, self.shell, password=None
+            )
         )
         return super(User, self).save(*args, **kwargs)
 
@@ -142,13 +232,40 @@ class User(TimeStampedModel, models.Model):
         for group in [
             ag.group for ag in AdditionalGroup.objects.filter(user=self)
         ]:
-            remove_ldap_user_from_group.delay(self.username, group.groupname)
-        delete_ldap_user.delay(self.username)
-        delete_ldap_group_if_empty.delay(self.group.groupname)
+            DeleteTaskResult.objects.create_deletetaskresult(
+                'usergroup',
+                '{0} in {1}'.format(self.username, group.groupname),
+                remove_ldap_user_from_group.delay(
+                    self.username, group.groupname)
+            )
+        DeleteTaskResult.objects.create_deletetaskresult(
+            'user', self.username,
+            delete_ldap_user.delay(self.username)
+        )
+        DeleteTaskResult.objects.create_deletetaskresult(
+            'group', self.group.groupname,
+            delete_ldap_group_if_empty.delay(self.group.groupname)
+        )
         self.group.delete()
         super(User, self).delete(*args, **kwargs)
 
 
+class UserTaskResultManager(TaskResultManager):
+
+    def create_usertaskresult(self, user, asyncresult, commit=False):
+        taskresult = self.create(asyncresult)
+        taskresult.user = user
+        taskresult.save()
+        return taskresult
+
+
+class UserTaskResult(TaskResult):
+
+    user = models.ForeignKey(User)
+
+    objects = UserTaskResultManager()
+
+
 class ShadowManager(models.Manager):
 
     def create_shadow(self, user, password):
@@ -223,13 +340,21 @@ class AdditionalGroup(TimeStampedModel, models.Model):
                 "You can not use a user's primary group."))
 
     def save(self, *args, **kwargs):
-        add_ldap_user_to_group.delay(
+        res = add_ldap_user_to_group.delay(
             self.user.username, self.group.groupname)
+        GroupTaskResult.objects.create(
+            group=self.group, task_uuid=res.id,
+            task_name=res.task_name
+        )
         super(AdditionalGroup, self).save(*args, **kwargs)
 
     def delete(self, *args, **kwargs):
-        remove_ldap_user_from_group.delay(
-            self.user.username, self.group.groupname)
+        DeleteTaskResult.objects.create_deletetaskresult(
+            'usergroup',
+            str(self),
+            remove_ldap_user_from_group.delay(
+                self.user.username, self.group.groupname)
+        )
         super(AdditionalGroup, self).delete(*args, **kwargs)
 
     def __str__(self):