Example #1
0
    def test_get_current_rhic_lookup_tasks(self):
        cfg = config.get_rhic_serve_config_info()
        # Create a valid, in_progress task
        task_a = RHICLookupTask(uuid="11a1aa11-a11a-1a11-111a-a11111111111", completed=False)
        task_a.save()
        # Create a completed task
        task_b = RHICLookupTask(uuid="11a1aa11-a11a-1a11-111a-a22222222222", completed=True,
            initiated=datetime.now(tzutc()),
            modified=datetime.now(tzutc()))
        task_b.save()
        # Create a timedout incomplete task
        timeout_in_minutes = cfg["single_rhic_lookup_timeout_in_minutes"]
        expired_time = datetime.now(tzutc()) - timedelta(minutes=timeout_in_minutes+1)
        task_c = RHICLookupTask(uuid="11a1aa11-a11a-1a11-111a-a333333333333", completed=False, initiated=expired_time)
        task_c.save()
        # Create a completed expired task
        expired_hours = cfg["single_rhic_lookup_cache_unknown_in_hours"]
        expired_time = datetime.now(tzutc()) - timedelta(hours=expired_hours+1)
        task_d = RHICLookupTask(uuid="11a1aa11-a11a-1a11-111a-a444444444444", completed=True, modified=expired_time)
        task_d.save()

        # Ensure all tasks where created and have been saved in mongo
        current_tasks = [x.uuid for x in RHICLookupTask.objects()]
        for t in [task_a, task_b, task_c, task_d]:
            self.assertTrue(t.uuid in current_tasks)

        # In-progress, valid task
        task = identity.get_current_rhic_lookup_tasks(task_a.uuid)
        self.assertIsNotNone(task)
        self.assertEquals(task.uuid, task_a.uuid)

        # Completed, valid task
        task = identity.get_current_rhic_lookup_tasks(task_b.uuid)
        self.assertIsNotNone(task)
        self.assertEquals(task.uuid, task_b.uuid)

        # In-progress, timed out task
        task = identity.get_current_rhic_lookup_tasks(task_c.uuid)
        self.assertIsNone(task)
        found = [x.uuid for x in RHICLookupTask.objects()]
        self.assertTrue(task_c.uuid not in found)

        # Completed, cache time expired task
        task = identity.get_current_rhic_lookup_tasks(task_d.uuid)
        self.assertIsNone(task)
        found = [x.uuid for x in RHICLookupTask.objects()]
        self.assertTrue(task_d.uuid not in found)

        # Be sure of the 4 tasks we created, the expired and timedout were removed
        # while the 2 good tasks remained
        self.assertEquals(len(found), 2)
        self.assertTrue(task_a.uuid in found)
        self.assertTrue(task_b.uuid in found)
def complete_rhic_lookup_task(uuid, status_code):
    """
    @param uuid: RHIC uuid
    @param status_code: HTTP status code from RHIC lookup
    @return: None
    """
    _LOG.info("complete_rhic_lookup_task(rhic_uuid='%s', status_code='%s') invoked" % (uuid, status_code))
    current_task = identity.get_current_rhic_lookup_tasks(uuid)
    if not current_task:
        _LOG.warning("completed_rhic_lookup_task with status code '%s' called on uuid '%s' "
                     "yet no task was found" % (status_code, uuid))
        return None
    if status_code in [202, 404]:
        #   202 - in-progress tasks
        #   404 - lookups that received a definitive response of the RHIC not existing.
        current_task.task_id = None
        current_task.modified = datetime.now(tzutc())
        current_task.status_code = status_code
        current_task.completed = True
        if status_code == 202:
            # Parent is still processing request, task will remain active.
            current_task.completed = False
        current_task.save()
    else:
        # Task will be killed, it either succeeded with a '200' or an unexpected error was seen.
        msg = "Received [%s] for lookup of RHIC [%s]" % (status_code, uuid)
        if status_code in [200]:
            # 200 - RHIC was found in parent
            _LOG.info(msg)
        else:
            _LOG.error(msg)
        identity.delete_rhic_lookup(current_task)
    return None
def get_cached_status_code(uuid):
    """
    @param uuid: RHIC uuid
    @return:
    """
    t = identity.get_current_rhic_lookup_tasks(uuid)
    if t and t.completed:
        return t.status_code
    return None
def update_rhic_lookup_task(uuid, task_id):
    _LOG.info("update_rhic_lookup_task(rhic_uuid='%s', task_id='%s')" % (uuid, task_id))
    current_task = identity.get_current_rhic_lookup_tasks(uuid)
    if not current_task:
        current_task = RHICLookupTask(uuid=uuid, initiated=datetime.now(tzutc()))
    current_task.task_id = task_id
    current_task.modified = datetime.now(tzutc())
    current_task.completed = False
    current_task.save()
    _LOG.info("update_rhic_lookup_task(%s, %s) updated task to %s" % (uuid, task_id, current_task))
    return current_task
Example #5
0
 def handle_rhic_lookup(self, rhic_uuid):
     """
     Will look up if an existing lookup is in progress for this RHIC.
     If a task is found, will return it's status code if completed, or 202 to signal in progress
     If a task is not found, will create a new task and return 202 to signal in progress
     @param rhic_uuid:
     @return: status code to return for request
     @rtype: int
     """
     _LOG.info("Processing rhic_lookup for an unknown RHIC of UUID '%s' " % (rhic_uuid))
     task = get_current_rhic_lookup_tasks(rhic_uuid)
     if task:
         if task.completed:
             ret_code = 404
             if task.status_code:
                 ret_code = task.status_code
             _LOG.info("Using cached value %s" % (task))
             return ret_code
         else:
             _LOG.info("Lookup task in progress: %s" % (task))
             return 202
     task = identity_lookup.create_rhic_lookup_task(rhic_uuid)
     _LOG.info("Initiated new lookup task: %s" % (task))
     return 202