def test_abort(self):
rq1 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.NEW))
rq1.abort()
self.assertEqual(rq1.msg.status, Request.ABORTED)
rq2 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.WAITING))
rq2.abort()
self.assertEqual(rq2.msg.status, Request.ABORTED)
rq3 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.PREEMPTING))
rq3.abort()
self.assertEqual(rq3.msg.status, Request.ABORTED)
rq4 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.PREEMPTED))
rq4.abort()
self.assertEqual(rq4.msg.status, Request.ABORTED)
rq5 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.GRANTED))
rq5.abort()
self.assertEqual(rq5.msg.status, Request.ABORTED)
def test_reject(self):
rq1 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.NEW))
rq1.reject()
self.assertEqual(rq1.msg.status, Request.REJECTED)
rq2 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.WAITING))
rq2.reject()
self.assertEqual(rq2.msg.status, Request.REJECTED)
rq3 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.PREEMPTING))
rq3.reject()
self.assertEqual(rq3.msg.status, Request.REJECTED)
rq4 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.PREEMPTED))
rq4.reject()
self.assertEqual(rq4.msg.status, Request.REJECTED)
rq5 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.GRANTED))
self.assertRaises(TransitionError, rq5.reject)
def test_constructor(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rq1 = ResourceRequest(msg1)
self.assertIsNotNone(rq1)
self.assertEqual(str(rq1),
'id: 01234567-89ab-cdef-fedc-ba9876543210\n'
' priority: 0\n'
' resources: \n'
' linux.precise.ros.segbot.*/test_rapp\n'
' status: 0')
self.assertEqual(rq1.msg.status, Request.NEW)
self.assertEqual(rq1.msg.resources, [TEST_WILDCARD])
# why is this broken???
#self.assertEqual(rq1.get_uuid, TEST_UUID)
rq2 = ResourceRequest(Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_RESOURCE],
status=Request.NEW))
self.assertEqual(rq2.msg.status, Request.NEW)
self.assertEqual(rq2.msg.resources, [TEST_RESOURCE])
self.assertEqual(rq2.get_uuid(), DIFF_UUID)
self.assertEqual(str(rq2),
'id: 01234567-cdef-fedc-89ab-ba9876543210\n'
' priority: 0\n'
' resources: \n'
' linux.precise.ros.segbot.roberto/test_rapp\n'
' status: 0')
def test_canceled_merge_plus_new_request(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.CANCELING)
msg2 = Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rset = RequestSet([msg1, msg2], RQR_UUID)
self.assertEqual(len(rset), 2)
self.assertIn(TEST_UUID, rset)
self.assertIn(DIFF_UUID, rset)
self.assertEqual(rset[DIFF_UUID].msg.status, Request.NEW)
# merge a canceled request: TEST_UUID should be deleted, but
# DIFF_UUID should not
msg3 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.CLOSED)
rel_rset = RequestSet([msg3], RQR_UUID)
rset.merge(rel_rset)
self.assertEqual(len(rset), 1)
self.assertNotIn(TEST_UUID, rset)
self.assertIn(DIFF_UUID, rset)
self.assertEqual(rset[DIFF_UUID].msg.status, Request.NEW)
# make a fresh object like the original msg2 for comparison
msg4 = Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
self.assertEqual(rset, RequestSet([msg4], RQR_UUID))
self.assertNotEqual(rset, rel_rset)
def test_constructor(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rq1 = ResourceRequest(msg1)
self.assertIsNotNone(rq1)
self.assertEqual(
str(rq1), """id: 01234567-89ab-cdef-fedc-ba9876543210
priority: 0
resources:
rocon:/segbot#test_rapp
status: 0""")
self.assertEqual(rq1.msg.status, Request.NEW)
self.assertEqual(rq1.msg.resources, [TEST_WILDCARD])
self.assertEqual(rq1.uuid, TEST_UUID)
rq2 = ResourceRequest(
Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_RESOURCE],
status=Request.NEW))
self.assertEqual(rq2.msg.status, Request.NEW)
self.assertEqual(rq2.msg.resources, [TEST_RESOURCE])
self.assertEqual(rq2.uuid, DIFF_UUID)
self.assertEqual(
str(rq2), """id: 01234567-cdef-fedc-89ab-ba9876543210
priority: 0
resources:
rocon:/segbot/roberto#test_rapp
status: 0""")
def test_validate(self):
rq1 = ResourceRequest(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.NEW))
self.assertTrue(rq1._validate(Request.GRANTED))
self.assertTrue(rq1._validate(Request.PREEMPTING))
self.assertFalse(rq1._validate(Request.CLOSED))
def test_allocate_permutation_two_resources(self):
""" Request a regexp allocation followed by an exact
allocation. Initially the exact resource gets assigned to the
regexp, so the second part of the request fails. The
allocator must try the other permutation for it to succeed.
"""
pool = ResourcePool(
KnownResources(resources=[
CurrentStatus(uri=MARVIN_NAME,
rapps={TELEOP_RAPP, EXAMPLE_RAPP}),
CurrentStatus(uri=ROBERTO_NAME, rapps={TELEOP_RAPP})
]))
rq = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID),
resources=[
Resource(rapp=TELEOP_RAPP, uri=ANY_NAME),
Resource(rapp=EXAMPLE_RAPP, uri=MARVIN_NAME)
]))
alloc = pool.allocate(rq)
self.assertTrue(alloc)
self.assertEqual(len(alloc), 2)
self.assertEqual(pool[MARVIN_NAME].status, CurrentStatus.ALLOCATED)
self.assertEqual(pool[MARVIN_NAME].owner, RQ_UUID)
self.assertEqual(pool[ROBERTO_NAME].status, CurrentStatus.ALLOCATED)
self.assertEqual(pool[ROBERTO_NAME].owner, RQ_UUID)
self.assertEqual(alloc[0], Resource(rapp=TELEOP_RAPP,
uri=ROBERTO_NAME))
self.assertEqual(alloc[1], Resource(rapp=EXAMPLE_RAPP,
uri=MARVIN_NAME))
def new_request(self, resources, priority=None, uuid=None):
""" Add a new scheduler request.
Call this method for each desired new request, then invoke
:py:meth:`.send_requests` to notify the scheduler.
:param resources: ROCON resources requested
:type resources: list of scheduler_msgs/Resource
:param priority: Scheduling priority of this request. If
``None`` provided, use this requester's priority.
:type priority: int
:param uuid: UUID_ of this request. If ``None`` provided, a
random UUID will be assigned.
:type uuid: :class:`uuid.UUID` or ``None``
:returns: UUID (:class:`uuid.UUID`) assigned.
:raises: :exc:`.WrongRequestError` if request already exists.
"""
if priority is None:
priority = self.priority
if uuid is None:
uuid = unique_id.fromRandom()
if uuid in self.rset:
raise WrongRequestError('UUID already in use.')
msg = Request(id=unique_id.toMsg(uuid),
priority=priority,
resources=resources,
status=Request.NEW)
self.rset[uuid] = ResourceRequest(msg)
return uuid
def test_allocate_four_resources_success(self):
""" Similar to test_allocate_four_resources_failure(), but the
order of the request is different, so the allocator succeeds.
"""
pool = ResourcePool(
KnownResources(resources=[
CurrentStatus(uri=DUDE1_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE2_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE3_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE4_NAME,
rapps={TELEOP_RAPP, EXAMPLE_RAPP})
]))
rq = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID),
resources=[
Resource(rapp=EXAMPLE_RAPP, uri=DUDE4_NAME),
Resource(rapp=TELEOP_RAPP, uri=DUDE2_NAME),
Resource(rapp=TELEOP_RAPP, uri=DUDE3_NAME),
Resource(rapp=TELEOP_RAPP, uri=ANY_NAME)
]))
alloc = pool.allocate(rq)
self.assertTrue(alloc)
bot_names = [DUDE4_NAME, DUDE2_NAME, DUDE3_NAME, DUDE1_NAME]
for name, i in zip(bot_names, range(4)):
self.assertEqual(pool[name].status, CurrentStatus.ALLOCATED)
self.assertEqual(alloc[i].uri, name)
def test_allocate_four_resources_failure(self):
""" Similar to test_allocate_permutation_two_resources(), but
here there are more permutations, so the allocator gives up
after the initial failure.
"""
pool = ResourcePool(
KnownResources(resources=[
CurrentStatus(uri=DUDE1_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE2_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE3_NAME, rapps={TELEOP_RAPP}),
CurrentStatus(uri=DUDE4_NAME,
rapps={TELEOP_RAPP, EXAMPLE_RAPP})
]))
rq = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID),
resources=[
Resource(rapp=TELEOP_RAPP, uri=ANY_NAME),
Resource(rapp=EXAMPLE_RAPP, uri=DUDE4_NAME),
Resource(rapp=TELEOP_RAPP, uri=DUDE2_NAME),
Resource(rapp=TELEOP_RAPP, uri=DUDE3_NAME)
]))
self.assertRaises(InvalidRequestError, pool.allocate, rq)
for name in [DUDE1_NAME, DUDE2_NAME, DUDE3_NAME, DUDE4_NAME]:
self.assertEqual(pool[name].status, CurrentStatus.AVAILABLE)
self.assertIsNone(pool[name].owner)
def test_one_request_set(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rset = RequestSet([msg1], RQR_UUID, contents=ResourceReply)
self.assertEqual(len(rset), 1)
self.assertTrue(TEST_UUID in rset)
self.assertEqual(rset[TEST_UUID].msg, msg1)
self.assertEqual(rset.get(TEST_UUID), rset[TEST_UUID])
self.assertFalse(DIFF_UUID in rset)
self.assertIsNone(rset.get(DIFF_UUID))
self.assertEqual(rset.get(DIFF_UUID, 10), 10)
self.assertTrue(rset == RequestSet([msg1], RQR_UUID))
self.assertTrue(rset == RequestSet([msg1], RQR_UUID,
contents=ResourceReply))
rs2 = copy.deepcopy(rset)
self.assertTrue(rset == rs2)
rset_str = """requester_id: 01234567-89ab-cdef-0123-456789abcdef
requests:
id: 01234567-89ab-cdef-fedc-ba9876543210
priority: 0
resources:
linux.precise.ros.segbot.*/test_rapp
status: 0"""
self.assertEqual(str(rset), rset_str)
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg1])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
def test_insufficient_resources(self):
# ask for two when there's only one
pool = ResourcePool(KnownResources(resources=[ROBERTO]))
rq1 = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID),
resources=[ANY_RESOURCE, ANY_RESOURCE]))
alloc1 = pool.allocate(rq1)
self.assertFalse(alloc1)
self.assertEqual(pool[ROBERTO_NAME].status, CurrentStatus.AVAILABLE)
self.assertIsNone(pool[ROBERTO_NAME].owner)
def assert_invalid(self, request_type, old_status,
operation, exception, *args):
"""
Assert that *request_type* with *old_status* rejects named
*operation*, raising *exception*.
"""
rq = request_type(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=old_status))
op_method = getattr(rq, operation)
self.assertRaises(exception, op_method, *args)
def test_heap_queue(self):
qe1 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[ROBERTO_RESOURCE],
priority=10)
), RQR_ID)
qe2 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[MARVIN_RESOURCE],
priority=0)
), RQR_ID)
self.assertLess(qe1, qe2) # due to higher priority
h = []
heapq.heappush(h, qe2)
heapq.heappush(h, qe1)
self.assertEqual(len(h), 2)
self.assertEqual(heapq.heappop(h), qe1)
self.assertEqual(len(h), 1)
heapq.heappush(h, qe1)
self.assertEqual(len(h), 2)
self.assertEqual(heapq.heappop(h), qe1)
qe3 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[ROBERTO_RESOURCE])
), RQR_ID)
qe4 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[MARVIN_RESOURCE])
), RQR_ID)
self.assertLess(qe3, qe4) # due to sequence number
heapq.heappush(h, qe4)
heapq.heappush(h, qe3)
heapq.heappush(h, qe1)
self.assertEqual(len(h), 4)
self.assertEqual(heapq.heappop(h), qe1)
self.assertEqual(heapq.heappop(h), qe2)
self.assertEqual(heapq.heappop(h), qe3)
self.assertEqual(heapq.heappop(h), qe4)
self.assertEqual(len(h), 0)
self.assertRaises(IndexError, heapq.heappop, h)
def test_single_merge(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rset = RequestSet([msg1], RQR_UUID)
self.assertEqual(rset[TEST_UUID].msg.status, Request.NEW)
self.assertEqual(rset[TEST_UUID].msg.resources, [TEST_WILDCARD])
self.assertEqual(rset[TEST_UUID].msg.id, unique_id.toMsg(TEST_UUID))
# merge an updated request set: resource list should change
msg2 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.GRANTED)
rset.merge(RequestSet([msg2], RQR_UUID, contents=ActiveRequest))
self.assertEqual(len(rset), 1)
self.assertIn(TEST_UUID, rset)
self.assertEqual(rset[TEST_UUID].msg.status, Request.GRANTED)
self.assertEqual(rset[TEST_UUID].msg.resources, [TEST_RESOURCE])
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg2])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
def test_allocate(self):
res1 = PoolResource(copy.deepcopy(TEST_RESOURCE))
self.assertEqual(res1.status, CurrentStatus.AVAILABLE)
self.assertEqual(res1.owner, None)
res1.allocate(copy.deepcopy(ROBERTO_REQUEST))
self.assertEqual(res1.status, CurrentStatus.ALLOCATED)
self.assertEqual(res1.owner, RQ_UUID)
self.assertRaises(
ResourceNotAvailableError, res1.allocate,
ActiveRequest(
Request(id=unique_id.toMsg(DIFF_UUID),
resources=[ROBERTO_RESOURCE])))
def test_two_request_set(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD])
msg2 = Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_RESOURCE])
rset = RequestSet([msg1, msg2], RQR_UUID)
self.assertEqual(len(rset), 2)
self.assertIn(TEST_UUID, rset)
self.assertIn(DIFF_UUID, rset)
self.assertEqual(rset[TEST_UUID].msg, msg1)
self.assertEqual(rset[DIFF_UUID].msg, msg2)
self.assertEqual(rset.get(TEST_UUID), rset[TEST_UUID])
self.assertEqual(rset.get(DIFF_UUID), rset[DIFF_UUID])
self.assertEqual(rset, RequestSet([msg1, msg2], RQR_UUID))
self.assertEqual(rset, RequestSet([msg2, msg1], RQR_UUID))
self.assertNotEqual(rset, RequestSet([msg1], RQR_UUID))
self.assertNotEqual(rset, RequestSet([msg2], RQR_UUID))
self.assertNotEqual(rset, RequestSet([], RQR_UUID))
rs2 = copy.deepcopy(rset)
self.assertEqual(rset, rs2)
rs2[TEST_UUID]._transition(EVENT_GRANT)
self.assertNotEqual(rset, rs2)
def new_request(self,
resources,
priority=None,
uuid=None,
reservation=rospy.Time(),
hold_time=rospy.Duration()):
""" Add a new scheduler request.
Call this method for each desired new request, then invoke
:py:meth:`.send_requests` to notify the scheduler.
:param resources: ROCON resources requested
:type resources: list of scheduler_msgs/Resource
:param priority: Scheduling priority of this request. If
``None`` provided, use this requester's default priority.
:type priority: int
:param uuid: UUID_ of this request. If ``None`` provided, a
random UUID will be assigned.
:type uuid: :class:`uuid.UUID` or ``None``
:param reservation: time when request desired, default:
immediately.
:type reservation: rospy.Time
:param hold_time: estimated duration the resource will be
held, default: unknown.
:type hold_time: rospy.Duration
:returns: UUID (:class:`uuid.UUID`) assigned.
:raises: :exc:`.WrongRequestError` if request already exists.
"""
if priority is None:
priority = self.priority
status = Request.NEW
if reservation != rospy.Time():
status = Request.RESERVED
if uuid is None:
uuid = unique_id.fromRandom()
if uuid in self.rset:
raise WrongRequestError('UUID already in use.')
msg = Request(id=unique_id.toMsg(uuid),
priority=priority,
resources=resources,
status=status,
availability=reservation,
hold_time=hold_time)
with self.lock:
self.rset[uuid] = msg
return uuid
def test_release(self):
rq1 = ResourceRequest(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.GRANTED))
rq1.release()
self.assertEqual(rq1.msg.status, Request.RELEASING)
rq2 = ResourceRequest(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.WAITING))
rq2.release()
self.assertEqual(rq2.msg.status, Request.RELEASING)
rq3 = ResourceRequest(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.PREEMPTING))
rq3.release()
self.assertEqual(rq3.msg.status, Request.RELEASING)
rq4 = ResourceRequest(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.ABORTED))
self.assertRaises(TransitionError, rq4.release)
def assert_valid(self, request_type, old_status,
operation, new_status, *args):
"""
Assert that *request_type* with *old_status* accepts named
*operation*, yielding *new_status*.
:returns: request contents after the *operation*.
"""
rq = request_type(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=old_status))
getattr(rq, operation)(*args)
self.assertEqual(rq.msg.status, new_status)
return rq
def test_released_merge(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.RELEASING)
rset = RequestSet([msg1], RQR_UUID)
self.assertEqual(len(rset), 1)
self.assertTrue(TEST_UUID in rset)
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg1])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
# merge a released request: TEST_UUID should be deleted
msg2 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.RELEASED)
rel_rset = RequestSet([msg2], RQR_UUID, contents=ResourceReply)
rset.merge(rel_rset)
self.assertEqual(len(rset), 0)
self.assertFalse(TEST_UUID in rset)
self.assertEqual(rset, RequestSet([], RQR_UUID,
contents=ResourceReply))
self.assertNotEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
self.assertNotEqual(rset, rel_rset)
def test_canceled_merge(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.CANCELING)
rset = RequestSet([msg1], RQR_UUID)
self.assertEqual(len(rset), 1)
self.assertIn(TEST_UUID, rset)
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg1])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
# merge a canceled request: TEST_UUID should be deleted
msg2 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.CLOSED)
rel_rset = RequestSet([msg2], RQR_UUID, contents=ActiveRequest)
rset.merge(rel_rset)
self.assertEqual(len(rset), 0)
self.assertNotIn(TEST_UUID, rset)
self.assertEqual(rset, RequestSet([], RQR_UUID,
contents=ActiveRequest))
self.assertNotEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
self.assertNotEqual(rset, rel_rset)
def test_two_request_set(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD])
msg2 = Request(id=unique_id.toMsg(DIFF_UUID),
resources=[TEST_RESOURCE])
rset = RequestSet([msg1, msg2], RQR_UUID)
self.assertEqual(len(rset), 2)
self.assertTrue(TEST_UUID in rset)
self.assertTrue(DIFF_UUID in rset)
self.assertEqual(rset[TEST_UUID].msg, msg1)
self.assertEqual(rset[DIFF_UUID].msg, msg2)
self.assertEqual(rset.get(TEST_UUID), rset[TEST_UUID])
self.assertEqual(rset.get(DIFF_UUID), rset[DIFF_UUID])
self.assertTrue(rset == RequestSet([msg1, msg2], RQR_UUID))
self.assertTrue(rset == RequestSet([msg2, msg1], RQR_UUID))
self.assertTrue(rset != RequestSet([msg1], RQR_UUID))
self.assertTrue(rset != RequestSet([msg2], RQR_UUID))
self.assertTrue(rset != RequestSet([], RQR_UUID))
rs2 = copy.deepcopy(rset)
self.assertTrue(rset == rs2)
self.assertFalse(rset != rs2)
rs2[TEST_UUID]._update_status(Request.GRANTED)
self.assertTrue(rset != rs2)
self.assertFalse(rset == rs2)
def test_grant(self):
rq1 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW))
rq1.grant([TEST_RESOURCE])
self.assertEqual(rq1.msg.status, Request.GRANTED)
self.assertEqual(rq1.msg.resources, [TEST_RESOURCE])
rq2 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.WAITING))
rq2.grant([TEST_RESOURCE])
self.assertEqual(rq2.msg.status, Request.GRANTED)
self.assertEqual(rq2.msg.resources, [TEST_RESOURCE])
rq3 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.PREEMPTING))
self.assertRaises(TransitionError, rq3.grant, [TEST_RESOURCE])
rq4 = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.ABORTED))
self.assertRaises(TransitionError, rq4.grant, [TEST_RESOURCE])
def test_sort_diff_priority(self):
qe1 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[ROBERTO_RESOURCE],
priority=10)
), RQR_ID)
qe2 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[MARVIN_RESOURCE],
priority=0)
), RQR_ID)
self.assertLess(qe1, qe2)
self.assertEqual(sorted([qe2, qe1]), [qe1, qe2])
qe3 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[ROBERTO_RESOURCE])
), RQR_ID)
qe4 = QueueElement(ActiveRequest(
Request(id=unique_id.toMsg(RQ1_UUID),
resources=[MARVIN_RESOURCE])
), RQR_ID)
self.assertEqual(sorted([qe4, qe3]), [qe3, qe4])
self.assertEqual(sorted([qe4, qe1, qe3, qe2]),
[qe1, qe2, qe3, qe4])
def test_empty_merge(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rset = RequestSet([msg1], RQR_UUID)
self.assertEqual(len(rset), 1)
self.assertIn(TEST_UUID, rset)
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg1])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
# merge an empty request set: rset should remain the same
rset.merge(RequestSet([], RQR_UUID, contents=ActiveRequest))
self.assertEqual(len(rset), 1)
self.assertIn(TEST_UUID, rset)
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
def test_one_request_set(self):
msg1 = Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_WILDCARD],
status=Request.NEW)
rset = RequestSet([msg1], RQR_UUID, contents=ActiveRequest)
self.assertEqual(len(rset), 1)
self.assertIn(TEST_UUID, rset)
self.assertEqual(rset[TEST_UUID].msg, msg1)
self.assertEqual(rset.get(TEST_UUID), rset[TEST_UUID])
self.assertNotIn(DIFF_UUID, rset)
self.assertIsNone(rset.get(DIFF_UUID))
self.assertEqual(rset.get(DIFF_UUID, 10), 10)
self.assertEqual(rset, RequestSet([msg1], RQR_UUID))
self.assertEqual(rset,
RequestSet([msg1], RQR_UUID, contents=ActiveRequest))
rset_str = """requester_id: 01234567-89ab-cdef-0123-456789abcdef
requests:
id: 01234567-89ab-cdef-fedc-ba9876543210
priority: 0
resources:
rocon:/segbot#test_rapp
status: 0"""
self.assertEqual(str(rset), rset_str)
sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID),
requests=[msg1])
self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg)
# vary message contents:
rs2 = copy.deepcopy(rset)
self.assertEqual(rset, rs2)
rq = rs2.get(TEST_UUID)
rq.msg.priority = 10
self.assertNotEqual(rset, rs2)
rq.msg.priority = 0
self.assertEqual(rset, rs2)
rq.msg.availability = rospy.Time(1000.0)
self.assertNotEqual(rset, rs2)
rq.msg.availability = rospy.Time()
self.assertEqual(rset, rs2)
rq.msg.hold_time = rospy.Duration(1000.0)
self.assertNotEqual(rset, rs2)
rq.msg.hold_time = rospy.Duration()
self.assertEqual(rset, rs2)
rq.msg.resources = [TEST_RESOURCE]
self.assertNotEqual(rset, rs2)
rq.msg.resources = [TEST_WILDCARD]
self.assertEqual(rset, rs2)
from concert_scheduler_requests.priority_queue import *
# some resources for testing
RQR_ID = uuid.uuid4()
RQ1_UUID = uuid.uuid4()
RQ2_UUID = uuid.uuid4()
EXAMPLE_RAPP = 'tests/example_rapp'
MARVIN_NAME = 'rocon:/turtlebot/marvin'
MARVIN = Resource(uri=MARVIN_NAME, rapp=EXAMPLE_RAPP)
ROBERTO_NAME = 'rocon:/turtlebot/roberto'
ROBERTO = Resource(uri=ROBERTO_NAME, rapp=EXAMPLE_RAPP)
# some useful Resource and Request messages
MARVIN_RESOURCE = Resource(rapp=EXAMPLE_RAPP, uri=MARVIN_NAME)
MARVIN_REQUEST = ActiveRequest(Request(
id=unique_id.toMsg(RQ1_UUID),
resources=[MARVIN_RESOURCE]))
ROBERTO_RESOURCE = Resource(rapp=EXAMPLE_RAPP, uri=ROBERTO_NAME)
ROBERTO_REQUEST = ActiveRequest(Request(
id=unique_id.toMsg(RQ2_UUID),
resources=[ROBERTO_RESOURCE]))
###############################
# queue element tests
###############################
class TestQueueElement(unittest.TestCase):
"""Unit tests for queue element class.
def test_free(self):
rq = ResourceReply(Request(id=unique_id.toMsg(TEST_UUID),
resources=[TEST_RESOURCE],
status=Request.RELEASING))
rq.free()
self.assertEqual(rq.msg.status, Request.RELEASED)
DUDE1_NAME = 'rocon:/turtlebot/dude1'
DUDE2_NAME = 'rocon:/turtlebot/dude2'
DUDE3_NAME = 'rocon:/turtlebot/dude3'
DUDE4_NAME = 'rocon:/turtlebot/dude4'
MARVIN_NAME = 'rocon:/turtlebot/marvin'
ROBERTO_NAME = 'rocon:/turtlebot/roberto'
MARVIN = CurrentStatus(uri=MARVIN_NAME, rapps=TEST_RAPPS)
ROBERTO = CurrentStatus(uri=ROBERTO_NAME, rapps=TEST_RAPPS)
SINGLETON_POOL = KnownResources(resources=[ROBERTO])
DOUBLETON_POOL = KnownResources(resources=[MARVIN, ROBERTO])
# some useful Resource and Request messages
ANY_RESOURCE = Resource(rapp=TELEOP_RAPP, uri=ANY_NAME)
ANY_REQUEST = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID), resources=[ANY_RESOURCE]))
MARVIN_RESOURCE = Resource(rapp=TELEOP_RAPP, uri=MARVIN_NAME)
ROBERTO_RESOURCE = Resource(rapp=TELEOP_RAPP, uri=ROBERTO_NAME)
ROBERTO_REQUEST = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID), resources=[ROBERTO_RESOURCE]))
NOT_TURTLEBOT_RESOURCE = Resource(rapp=TELEOP_RAPP, uri=NOT_TURTLEBOT_NAME)
NOT_TURTLEBOT_REQUEST = ActiveRequest(
Request(id=unique_id.toMsg(RQ_UUID), resources=[NOT_TURTLEBOT_RESOURCE]))
class TestResourcePool(unittest.TestCase):
"""Unit tests for simple scheduler resource pool class.
These tests do not require a running ROS core.
"""
