Exemple #1
0
    def _run_scheduled_calls(self):
        """
        Run call requests that are currently scheduled to run

        NOTE: the scheduler no longer schedules arbitrary call request, instead
        it now only supports call request from the itineraries package
        """
        coordinator = dispatch_factory.coordinator()

        for call_group in self._get_scheduled_call_groups():

            # this is a bit of hack and presumes that the first call in the call
            # group is the most important, need to re-think this and implement
            # something more general (counter-based?)
            # but for right now, the presumption is correct
            call_group[0].add_life_cycle_callback(dispatch_constants.CALL_COMPLETE_LIFE_CYCLE_CALLBACK,
                                                  scheduler_complete_callback)

            if len(call_group) == 1:
                call_report_list = [coordinator.execute_call_asynchronously(call_group[0])]
            else:
                call_report_list = coordinator.execute_multiple_calls(call_group)


            for call_request, call_report in zip(call_group, call_report_list):
                log_msg = _('Scheduled %(c)s: %(r)s [reasons: %(s)s]') % {'c': str(call_request),
                                                                          'r': call_report.response,
                                                                          's': pformat(call_report.reasons)}

                if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
                    _LOG.error(log_msg)
                else:
                    _LOG.info(log_msg)
Exemple #2
0
    def _run_scheduled_calls(self):
        """
        Find call requests that are currently scheduled to run
        """
        coordinator = dispatch_factory.coordinator()

        now = datetime.datetime.utcnow()
        query = {'next_run': {'$lte': now}}

        for scheduled_call in self.scheduled_call_collection.find(query):

            if not scheduled_call['enabled']:
                # update the next run information for disabled calls
                self.update_next_run(scheduled_call)
                continue

            serialized_call_request = scheduled_call['serialized_call_request']

            call_request = call.CallRequest.deserialize(serialized_call_request)
            call_request.add_life_cycle_callback(dispatch_constants.CALL_COMPLETE_LIFE_CYCLE_CALLBACK, scheduler_complete_callback)

            call_report = call.CallReport.from_call_request(call_request, schedule_id=str(scheduled_call['_id']))
            call_report = coordinator.execute_call_asynchronously(call_request, call_report)

            log_msg = _('Scheduled %(c)s: %(r)s [reasons: %(s)s]') % {'c': str(call_request),
                                                                      'r': call_report.response,
                                                                      's': pformat(call_report.reasons)}

            if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
                _LOG.error(log_msg)
            else:
                _LOG.info(log_msg)
Exemple #3
0
 def _get_call_report():
     context = dispatch_factory.context()
     coordinator = dispatch_factory.coordinator()
     call_report_list = coordinator.find_call_reports(call_request_id=context.call_request_id)
     if not call_report_list:
         return None
     return call_report_list[0].serialize()
Exemple #4
0
 def failed(self, reply):
     log.info('Task RMI (failed)\n%s', reply)
     taskid = reply.any
     exception = reply.exval
     traceback = reply.xstate['trace']
     coordinator = factory.coordinator()
     coordinator.complete_call_failure(taskid, exception, traceback)
Exemple #5
0
    def _get_scheduled_call_groups(self):
        """
        Get call requests, by call group, that are currently scheduled to run
        """

        coordinator = dispatch_factory.coordinator()

        now = datetime.datetime.utcnow()
        query = {'next_run': {'$lte': now}}

        for scheduled_call in self.scheduled_call_collection.find(query):

            if not scheduled_call['enabled']:
                # update the next run information for disabled calls
                self.update_next_run(scheduled_call)
                continue

            # get the itinerary call request and execute
            serialized_call_request = scheduled_call['serialized_call_request']
            call_request = call.CallRequest.deserialize(serialized_call_request)
            call_report = coordinator.execute_call_synchronously(call_request)

            # call request group is the return of an itinerary function
            call_request_group = call_report.result
            map(lambda r: setattr(r, 'schedule_id', str(scheduled_call['_id'])), call_request_group)
            yield  call_request_group
Exemple #6
0
    def _execute_itinerary(self, scheduled_call):
        """
        Execute the scheduled itinerary call request to get the call requests
        that implement the scheduled call

        :param scheduled_call: the scheduled call
        :type  scheduled_call: bson.BSON
        :return: call requests for the scheduled itinerary call
        :rtype:  list of pulp.server.dispatch.call.CallRequest
        """

        coordinator = dispatch_factory.coordinator()

        # scheduled calls are always itinerary calls
        itinerary_call_request = call.CallRequest.deserialize(scheduled_call['serialized_call_request'])
        itinerary_call_request.archive = False # don't keep a history of these calls

        itinerary_call_report = call.CallReport.from_call_request(itinerary_call_request)
        itinerary_call_report.serialize_result = False # don't try to serialize the result

        # use the coordinator to execute the itinerary call, it already has all
        # the machinery to handle the call request and report instances
        itinerary_call_report = coordinator.execute_call_synchronously(itinerary_call_request,
                                                                       itinerary_call_report)

        # the call request group is the result of the itinerary call
        call_request_group = itinerary_call_report.result

        self._set_call_group_scheduler_hooks(scheduled_call, call_request_group)

        return call_request_group
Exemple #7
0
    def _run_scheduled_calls(self):
        """
        Run call requests that are currently scheduled to run

        NOTE: the scheduler no longer schedules arbitrary call request, instead
        it now only supports call request from the itineraries package
        """
        coordinator = dispatch_factory.coordinator()

        for call_group in self._get_scheduled_call_groups():

            for call_request in call_group:
                call_request.add_life_cycle_callback(dispatch_constants.CALL_COMPLETE_LIFE_CYCLE_CALLBACK,
                                                     scheduler_complete_callback)

            if len(call_group) == 1:
                call_report_list = [coordinator.execute_call_asynchronously(call_group[0])]
            else:
                call_report_list = coordinator.execute_multiple_calls(call_group)


            for call_request, call_report in zip(call_group, call_report_list):
                log_msg = _('Scheduled %(c)s: %(r)s [reasons: %(s)s]') % {'c': str(call_request),
                                                                          'r': call_report.response,
                                                                          's': pformat(call_report.reasons)}

                if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
                    _LOG.error(log_msg)
                else:
                    _LOG.info(log_msg)
Exemple #8
0
 def DELETE(self, task_group_id):
     coordinator = dispatch_factory.coordinator()
     results = coordinator.cancel_multiple_calls(task_group_id)
     if not results:
         raise TaskGroupNotFound(task_group_id)
     if None in results.values():
         raise TaskGroupCancelNotImplemented(task_group_id)
     return self.accepted(results)
Exemple #9
0
 def GET(self):
     valid_filters = ['tag']
     filters = self.filters(valid_filters)
     criteria = {'tags': filters.get('tag', [])}
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(**criteria)
     serialized_call_reports = [c.serialize() for c in call_reports]
     return self.ok(serialized_call_reports)
Exemple #10
0
 def _get_call_report():
     context = dispatch_factory.context()
     coordinator = dispatch_factory.coordinator()
     call_report_list = coordinator.find_call_reports(
         call_request_id=context.call_request_id)
     if not call_report_list:
         return None
     return call_report_list[0].serialize()
Exemple #11
0
def _current_task_state():
    context = dispatch_factory.context()
    if context.call_request_id is None:
        return None
    coordinator = dispatch_factory.coordinator()
    tasks = coordinator._find_tasks(call_request_id=context.call_request_id)
    if not tasks:
        return None
    return tasks[0].state
Exemple #12
0
def execute_multiple(call_request_list):
    """
    Execute multiple calls as a task group via the coordinator.
    @param call_request_list: list of call request instances
    @type call_request_list: list
    """
    coordinator = dispatch_factory.coordinator()
    call_report_list = coordinator.execute_multiple_calls(call_request_list)
    raise MultipleOperationsPostponed(call_report_list)
Exemple #13
0
 def DELETE(self, task_id):
     coordinator = dispatch_factory.coordinator()
     result = coordinator.cancel_call(task_id)
     if result is None:
         raise MissingResource(task_id)
     if result is False:
         raise TaskCancelNotImplemented(task_id)
     link = serialization.link.current_link_obj()
     return self.accepted(link)
Exemple #14
0
 def DELETE(self, task_id):
     coordinator = dispatch_factory.coordinator()
     tasks = coordinator.find_tasks(task_id=task_id)
     if not tasks:
         raise QueuedCallNotFound(task_id)
     collection = QueuedCall.get_collection()
     collection.remove({'_id': tasks[0].queued_call_id}, safe=True)
     link = serialization.link.current_link_obj()
     return self.accepted(link)
Exemple #15
0
 def GET(self, task_group_id):
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(task_group_id=task_group_id)
     serialized_call_reports = [c.serialize() for c in call_reports]
     archived_calls = dispatch_history.find_archived_calls(task_group_id=task_group_id)
     serialized_call_reports.extend(c['serialized_call_report'] for c in archived_calls)
     if not serialized_call_reports:
         raise TaskGroupNotFound(task_group_id)
     return self.ok(serialized_call_reports)
Exemple #16
0
 def DELETE(self, call_request_id):
     coordinator = dispatch_factory.coordinator()
     tasks = coordinator._find_tasks(call_request_id=call_request_id)
     if not tasks:
         raise QueuedCallNotFound(call_request_id)
     collection = QueuedCall.get_collection()
     collection.remove({'_id': tasks[0].queued_call_id}, safe=True)
     link = serialization.link.current_link_obj()
     return self.accepted(link)
Exemple #17
0
 def GET(self):
     valid_filters = ['tag', 'id']
     filters = self.filters(valid_filters)
     criteria = {'tags': filters.get('tag', [])}
     if 'id' in filters:
         criteria['call_request_id_list'] = filters['id']
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(**criteria)
     serialized_call_reports = [c.serialize() for c in call_reports]
     return self.ok(serialized_call_reports)
Exemple #18
0
 def GET(self):
     valid_filters = ['tag', 'id']
     filters = self.filters(valid_filters)
     criteria = {'tags': filters.get('tag', [])}
     if 'id' in filters:
         criteria['call_request_id_list'] = filters['id']
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(**criteria)
     serialized_call_reports = [c.serialize() for c in call_reports]
     return self.ok(serialized_call_reports)
Exemple #19
0
 def GET(self, call_request_group_id):
     link = serialization.link.link_obj('/pulp/api/v2/task_groups/%s/' % call_request_group_id)
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(call_request_group_id=call_request_group_id)
     serialized_call_reports = [c.serialize() for c in call_reports]
     archived_calls = dispatch_history.find_archived_calls(task_group_id=call_request_group_id)
     serialized_call_reports.extend(c['serialized_call_report'] for c in archived_calls)
     if not serialized_call_reports:
         raise TaskGroupNotFound(call_request_group_id)
     map(lambda r: r.update(link), serialized_call_reports)
     return self.ok(serialized_call_reports)
Exemple #20
0
 def progress(self, reply):
     """
     Notification (reply) indicating an RMI has reported status.
     This information is relayed to the task coordinator.
     @param reply: A progress reply object.
     @type reply: L{gofer.rmi.async.Progress}
     """
     log.info('Task RMI (progress)\n%s', reply)
     taskid = reply.any
     coordinator = factory.coordinator()
     coordinator.report_call_progress(taskid, reply.details)
Exemple #21
0
 def progress(self, reply):
     """
     Notification (reply) indicating an RMI has reported status.
     This information is relayed to the task coordinator.
     @param reply: A progress reply object.
     @type reply: L{gofer.rmi.async.Progress}
     """
     log.info('Task RMI (progress)\n%s', reply)
     taskid = reply.any
     coordinator = factory.coordinator()
     coordinator.report_call_progress(taskid, reply.details)
Exemple #22
0
 def succeeded(self, reply):
     """
     Notification (reply) indicating an RMI succeeded.
     This information is relayed to the task coordinator.
     @param reply: A successful reply object.
     @type reply: L{gofer.rmi.async.Succeeded}
     """
     log.info('Task RMI (succeeded)\n%s', reply)
     taskid = reply.any
     result = reply.retval
     coordinator = factory.coordinator()
     coordinator.complete_call_success(taskid, result)
Exemple #23
0
 def DELETE(self, call_request_id):
     coordinator = dispatch_factory.coordinator()
     result = coordinator.cancel_call(call_request_id)
     if result is None:
         raise MissingResource(call_request_id)
     if result is False:
         raise TaskCancelNotImplemented(call_request_id)
     # if we've gotten here, the call request *should* exist
     call_report = coordinator.find_call_reports(call_request_id=call_request_id)[0]
     serialized_call_report = call_report.serialize()
     serialized_call_report.update(serialization.link.current_link_obj())
     return self.accepted(serialized_call_report)
Exemple #24
0
 def succeeded(self, reply):
     """
     Notification (reply) indicating an RMI succeeded.
     This information is relayed to the task coordinator.
     @param reply: A successful reply object.
     @type reply: L{gofer.rmi.async.Succeeded}
     """
     log.info('Task RMI (succeeded)\n%s', reply)
     taskid = reply.any
     result = reply.retval
     coordinator = factory.coordinator()
     coordinator.complete_call_success(taskid, result)
Exemple #25
0
 def DELETE(self, call_request_id):
     coordinator = dispatch_factory.coordinator()
     result = coordinator.cancel_call(call_request_id)
     if result is None:
         raise MissingResource(call_request_id)
     if result is False:
         raise TaskCancelNotImplemented(call_request_id)
     # if we've gotten here, the call request *should* exist
     call_report = coordinator.find_call_reports(
         call_request_id=call_request_id)[0]
     serialized_call_report = call_report.serialize()
     serialized_call_report.update(serialization.link.current_link_obj())
     return self.accepted(serialized_call_report)
Exemple #26
0
def execute_multiple(call_request_list):
    """
    Execute multiple calls as a task group via the coordinator.
    @param call_request_list: list of call request instances
    @type call_request_list: list
    """
    coordinator = dispatch_factory.coordinator()
    call_report_list = coordinator.execute_multiple_calls(call_request_list)
    if call_report_list[0].response is dispatch_constants.CALL_REJECTED_RESPONSE:
        # the coordinator will put the reasons on the call report that conflicted
        reasons = reduce(lambda p, c: c.reasons or p, call_report_list, None)
        raise ConflictingOperation(reasons)
    raise MultipleOperationsPostponed(call_report_list)
Exemple #27
0
 def failed(self, reply):
     """
     Notification (reply) indicating an RMI failed.
     This information is relayed to the task coordinator.
     @param reply: A failure reply object.
     @type reply: L{gofer.rmi.async.Failed}
     """
     log.info('Task RMI (failed)\n%s', reply)
     taskid = reply.any
     exception = reply.exval
     traceback = reply.xstate['trace']
     coordinator = factory.coordinator()
     coordinator.complete_call_failure(taskid, exception, traceback)
Exemple #28
0
 def GET(self):
     valid_filters = ['tag']
     filters = self.filters(valid_filters)
     criteria = {'tags': filters.get('tag', [])}
     # support legacy search criteria
     if 'task_id' in criteria:
         criteria['call_request_id'] = criteria.pop('task_id')
     if 'task_group_id' in criteria:
         criteria['call_request_group_id'] = criteria.pop('task_group_id')
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(**criteria)
     serialized_call_reports = [c.serialize() for c in call_reports]
     return self.ok(serialized_call_reports)
Exemple #29
0
 def failed(self, reply):
     """
     Notification (reply) indicating an RMI failed.
     This information is relayed to the task coordinator.
     @param reply: A failure reply object.
     @type reply: L{gofer.rmi.async.Failed}
     """
     log.info('Task RMI (failed)\n%s', reply)
     taskid = reply.any
     exception = reply.exval
     traceback = reply.xstate['trace']
     coordinator = factory.coordinator()
     coordinator.complete_call_failure(taskid, exception, traceback)
Exemple #30
0
def execute_async(controller, call_request, call_report=None):
    """
    Execute a call request asynchronously via the coordinator.
    @param controller: web services rest controller
    @type  controller: pulp.server.webservices.controller.base.JSONController
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @return: http server response
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call_asynchronously(call_request, call_report)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    raise OperationPostponed(call_report)
Exemple #31
0
 def GET(self, task_id):
     link = serialization.link.link_obj('/pulp/api/v2/tasks/%s/' % task_id)
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(task_id=task_id)
     if call_reports:
         serialized_call_report = call_reports[0].serialize()
         serialized_call_report.update(link)
         return self.ok(serialized_call_report)
     archived_calls = dispatch_history.find_archived_calls(task_id=task_id)
     if archived_calls.count() > 0:
         serialized_call_report = archived_calls[0]['serialized_call_report']
         serialized_call_report.update(link)
         return self.ok(serialized_call_report)
     raise TaskNotFound(task_id)
Exemple #32
0
def execute_multiple(call_request_list):
    """
    Execute multiple calls as a task group via the coordinator.
    @param call_request_list: list of call request instances
    @type call_request_list: list
    """
    coordinator = dispatch_factory.coordinator()
    call_report_list = coordinator.execute_multiple_calls(call_request_list)
    if call_report_list[
            0].response is dispatch_constants.CALL_REJECTED_RESPONSE:
        # the coordinator will put the reasons on the call report that conflicted
        reasons = reduce(lambda p, c: c.reasons or p, call_report_list, None)
        raise ConflictingOperation(reasons)
    raise MultipleOperationsPostponed(call_report_list)
Exemple #33
0
    def setUp(self):
        super(PulpWebserviceTests, self).setUp()
        self.coordinator = dispatch_factory.coordinator()
        self.success_failure = None
        self.result = None
        self.exception = None
        self.traceback = None

        # The built in PulpTest clean will automatically delete users between
        # test runs, so we can't just create the user in the class level setup.
        user_manager = manager_factory.user_manager()
        roles = []
        roles.append(manager_factory.role_manager().super_user_role)
        user_manager.create_user(login='******', password='******', roles=roles)
Exemple #34
0
    def setUp(self):
        super(PulpWebserviceTests, self).setUp()
        self.coordinator = dispatch_factory.coordinator()
        self.success_failure = None
        self.result = None
        self.exception = None
        self.traceback = None

        # The built in PulpTest clean will automatically delete users between
        # test runs, so we can't just create the user in the class level setup.
        user_manager = manager_factory.user_manager()
        roles = []
        roles.append(manager_factory.role_manager().super_user_role)
        user_manager.create_user(login='******', password='******', roles=roles)
Exemple #35
0
def execute_async(controller, call_request, call_report=None):
    """
    Execute a call request asynchronously via the coordinator.
    @param controller: web services rest controller
    @type  controller: pulp.server.webservices.controller.base.JSONController
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @return: http server response
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call_asynchronously(
        call_request, call_report)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    raise OperationPostponed(call_report)
Exemple #36
0
 def DELETE(self, call_request_group_id):
     coordinator = dispatch_factory.coordinator()
     results = coordinator.cancel_multiple_calls(call_request_group_id)
     if not results:
         raise TaskGroupNotFound(call_request_group_id)
     if reduce(lambda p, v: p and (v is None), results.values(), True):
         # in other words, all results values are None
         raise TaskGroupCancelNotImplemented(call_request_group_id)
     # if we've gotten this far, the call requests exist and have been cancelled
     call_reports = coordinator.find_call_reports(call_request_group_id=call_request_group_id)
     serialized_call_reports = [c.serialize() for c in call_reports]
     link = serialization.link.current_link_obj()
     for s in serialized_call_reports:
         s.update(link)
     return self.accepted(serialized_call_reports)
Exemple #37
0
    def _run_scheduled_calls(self):
        """
        Run the scheduled calls that are due.
        """

        coordinator = dispatch_factory.coordinator()

        for call_request_group in self._get_call_request_groups_for_scheduled_itineraries():

            # dispatch the itinerary
            call_report_list = coordinator.execute_multiple_calls(call_request_group)

            # log the scheduled itinerary's dispatch
            for call_request, call_report in zip(call_request_group, call_report_list):
                _LOG.info('Scheduled %s: %s [reasons: %s]' %
                          (str(call_request), call_report.response, pformat(call_report.reasons)))
Exemple #38
0
 def DELETE(self, call_request_group_id):
     coordinator = dispatch_factory.coordinator()
     results = coordinator.cancel_multiple_calls(call_request_group_id)
     if not results:
         raise TaskGroupNotFound(call_request_group_id)
     if reduce(lambda p, v: p and (v is None), results.values(), True):
         # in other words, all results values are None
         raise TaskGroupCancelNotImplemented(call_request_group_id)
     # if we've gotten this far, the call requests exist and have been cancelled
     call_reports = coordinator.find_call_reports(
         call_request_group_id=call_request_group_id)
     serialized_call_reports = [c.serialize() for c in call_reports]
     link = serialization.link.current_link_obj()
     for s in serialized_call_reports:
         s.update(link)
     return self.accepted(serialized_call_reports)
Exemple #39
0
def execute_sync(call_request, call_report=None, timeout=timedelta(seconds=20)):
    """
    Execute a call request synchronously via the coordinator.
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @param timeout: time to wait for task to start before raising and exception
    @type  timeout: datetime.timedelta
    @return: return value from call in call request
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call_synchronously(call_request, call_report, timeout)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    if call_report.state is dispatch_constants.CALL_ERROR_STATE:
        raise call_report.exception, None, call_report.traceback
    return call_report.result
Exemple #40
0
def execute(call_request, call_report=None):
    """
    Execute a call request through the controller and return the result iff the
    call was executed immediately.
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @return: return value from call in call request
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call(call_request, call_report)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    if call_report.state in dispatch_constants.CALL_INCOMPLETE_STATES:
        raise OperationPostponed(call_report)
    if call_report.state is dispatch_constants.CALL_ERROR_STATE:
        raise call_report.exception, None, call_report.traceback
    return call_report.result
Exemple #41
0
def execute(call_request, call_report=None):
    """
    Execute a call request through the controller and return the result iff the
    call was executed immediately.
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @return: return value from call in call request
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call(call_request, call_report)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    if call_report.state in dispatch_constants.CALL_INCOMPLETE_STATES:
        raise OperationPostponed(call_report)
    if call_report.state is dispatch_constants.CALL_ERROR_STATE:
        raise call_report.exception, None, call_report.traceback
    return call_report.result
Exemple #42
0
 def POST(self, uuid):
     """
     Agent (asynchronous) RMI call back.
     Update the related task by ID.
     """
     body = self.params()
     _LOG.info('agent (%s) reply:\n%s', uuid, body)
     coordinator = dispatch_factory.coordinator()
     call_request_id = body['any']
     if body['status'] == 200:
         result = body['reply']
         coordinator.complete_call_success(call_request_id, result)
     else:
         raised = body['exception']
         exception = raised['xmsg']
         traceback = raised['xstate']['trace']
         coordinator.complete_call_failure(call_request_id, exception, traceback)
     return self.ok({})
Exemple #43
0
 def GET(self, call_request_group_id):
     link = serialization.link.link_obj('/pulp/api/v2/task_groups/%s/' %
                                        call_request_group_id)
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(
         call_request_group_id=call_request_group_id)
     found_call_request_ids = set(c.call_request_id for c in call_reports)
     serialized_call_reports = [c.serialize() for c in call_reports]
     archived_calls = dispatch_history.find_archived_calls(
         call_request_group_id=call_request_group_id)
     serialized_call_reports.extend(
         c['serialized_call_report'] for c in archived_calls
         if c['serialized_call_report']['call_request_id'] not in
         found_call_request_ids)
     if not serialized_call_reports:
         raise TaskGroupNotFound(call_request_group_id)
     map(lambda r: r.update(link), serialized_call_reports)
     return self.ok(serialized_call_reports)
Exemple #44
0
 def GET(self, call_request_id):
     link = serialization.link.link_obj('/pulp/api/v2/tasks/%s/' %
                                        call_request_id)
     coordinator = dispatch_factory.coordinator()
     call_reports = coordinator.find_call_reports(
         call_request_id=call_request_id)
     if call_reports:
         serialized_call_report = call_reports[0].serialize()
         serialized_call_report.update(link)
         return self.ok(serialized_call_report)
     archived_calls = dispatch_history.find_archived_calls(
         call_request_id=call_request_id)
     if archived_calls.count() > 0:
         serialized_call_report = archived_calls[0][
             'serialized_call_report']
         serialized_call_report.update(link)
         return self.ok(serialized_call_report)
     raise TaskNotFound(call_request_id)
Exemple #45
0
 def POST(self, uuid):
     """
     Agent (asynchronous) RMI call back.
     Update the related task by ID.
     """
     body = self.params()
     _LOG.info('agent (%s) reply:\n%s', uuid, body)
     coordinator = dispatch_factory.coordinator()
     task_id = body['any']
     if body['status'] == 200:
         result = body['reply']
         coordinator.complete_call_success(task_id, result)
     else:
         raised = body['exception']
         exception = raised['xmsg']
         traceback = raised['xstate']['trace']
         coordinator.complete_call_failure(task_id, exception, traceback)
     return self.ok({})
Exemple #46
0
def execute_sync_ok(controller, call_request, timeout=timedelta(seconds=20)):
    """
    Execute a call request synchronously via the coordinator.
    @param controller: web services rest controller
    @type  controller: pulp.server.webservices.controller.base.JSONController
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @param timeout: time to wait for task to start before raising and exception
    @type  timeout: datetime.timedelta
    @return: http server response
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call_synchronously(call_request,
                                                         timeout=timeout)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    if call_report.state is dispatch_constants.CALL_ERROR_STATE:
        raise call_report.exception, None, call_report.traceback
    return controller.ok(call_report.result)
Exemple #47
0
    def _get_scheduled_call_groups(self):
        """
        Get call requests, by call group, that are currently scheduled to run
        """

        coordinator = dispatch_factory.coordinator()

        now = datetime.datetime.utcnow()
        query = {'next_run': {'$lte': now}}

        for scheduled_call in self.scheduled_call_collection.find(query):

            # updating the next run time will keep the scheduler from finding
            # this call again before it completes
            # it's also important to update the next run time for disabled calls
            self.update_next_run(scheduled_call)

            if not scheduled_call['enabled']:
                continue

            # test to see if any tasks from this schedule are already in the queue
            already_queued = coordinator.find_call_reports(schedule_id=scheduled_call['id'])
            if already_queued:
                log_msg = _('Schedule %(s)s skipped: last scheduled call still running') % {'s': scheduled_call['id']}
                _LOG.info(log_msg)
                continue

            # scheduled calls are always itinerary calls: calls that generate
            # call requests
            # get the itinerary call request and execute
            serialized_call_request = scheduled_call['serialized_call_request']
            itinerary_call_request = call.CallRequest.deserialize(serialized_call_request)
            itinerary_call_request.archive = False
            itinerary_call_report = call.CallReport.from_call_request(itinerary_call_request)
            itinerary_call_report.serialize_result = False
            itinerary_call_report = coordinator.execute_call_synchronously(itinerary_call_request, itinerary_call_report)

            # call request group is the return of an itinerary function
            call_request_group = itinerary_call_report.result
            map(lambda r: setattr(r, 'schedule_id', str(scheduled_call['_id'])), call_request_group)
            yield  call_request_group
Exemple #48
0
def execute_created(controller, call_request, location):
    """
    Execute a call request via the coordinator.
    @param controller: web services rest controller
    @type  controller: pulp.server.webservices.controller.base.JSONController
    @param call_request: call request to execute
    @type  call_request: pulp.server.dispatch.call.CallRequest
    @param location: the location of the created resource
    @type  location: str
    @return: http server response
    @deprecated: create should always return an _href field which requires post
                 return processing
    """
    coordinator = dispatch_factory.coordinator()
    call_report = coordinator.execute_call(call_request)
    if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE:
        raise ConflictingOperation(call_report.reasons)
    # covers postponed and accepted
    if call_report.state in dispatch_constants.CALL_INCOMPLETE_STATES:
        raise OperationPostponed(call_report)
    if call_report.state is dispatch_constants.CALL_ERROR_STATE:
        raise call_report.exception, None, call_report.traceback
    return controller.created(location, call_report.result)
Exemple #49
0
 def GET(self, call_request_id):
     coordinator = dispatch_factory.coordinator()
     tasks = coordinator._find_tasks(call_request_id=call_request_id)
     if not tasks:
         raise QueuedCallNotFound(call_request_id)
     return self.ok(tasks[0].queued_call_id)
Exemple #50
0
 def setUp(self):
     PulpAsyncServerTests.setUp(self)
     TaskQueue.install()
     self.coordinator = dispatch_factory.coordinator()