def find(self, request):
"""Find the specified resource.
:type request: FindRequest
:rtype: FindResponse
:raise: InvalidScheduler
"""
if self._configured == ConfigStates.UNINITIALIZED:
raise InvalidScheduler()
# Host service only has a single scheduler
request.scheduler_id = None
futures = []
for agent in self._get_hosts():
future = self._threadpool.submit(self._find_worker, agent.address,
agent.port, agent.id, request)
futures.append(future)
done, not_done = concurrent.futures.wait(futures, timeout=FIND_TIMEOUT)
self._logger.info("Find responses received: %d, timed out: %d",
len(done), len(not_done))
for future in done:
response = future.result()
if response.result == FindResultCode.OK:
return response
return FindResponse(FindResultCode.NOT_FOUND)
def test_find_resource_not_found(self, client_class):
client_class.side_effect = self.create_fake_client
bar_client = MagicMock()
bar_response = FindResponse(FindResultCode.NOT_FOUND)
bar_client.find.return_value = bar_response
self._clients["bar"] = bar_client
baz_client = MagicMock()
baz_response = FindResponse(FindResultCode.NOT_FOUND)
baz_client.find.return_value = baz_response
self._clients["baz"] = baz_client
scheduler = BranchScheduler("foo", 9)
scheduler.configure([ChildInfo(id="bar", address="bar"),
ChildInfo(id="baz", address="baz")])
response = scheduler.find(FindRequest())
assert_that(response.result, is_(FindResultCode.NOT_FOUND))
def test_find_resource_found(self, client_class):
client_class.side_effect = self.create_fake_client
bar_client = MagicMock()
bar_response = FindResponse(FindResultCode.NOT_FOUND)
bar_client.host_find.return_value = bar_response
self._clients["bar"] = bar_client
baz_client = MagicMock()
baz_response = FindResponse(FindResultCode.OK)
baz_client.host_find.return_value = baz_response
self._clients["baz"] = baz_client
scheduler = LeafScheduler("foo", 9, False)
scheduler.configure([ChildInfo(id="bar", address="bar"),
ChildInfo(id="baz", address="baz")])
response = scheduler.find(self._place_request())
assert_that(response, is_(same_instance(baz_response)))
def find(self, request):
"""Find the specified resource.
:type request: FindRequest
:rtype: FindResponse
"""
try:
scheduler = self._get_scheduler(request.scheduler_id)
return scheduler.find(request)
except InvalidScheduler:
return FindResponse(FindResultCode.INVALID_SCHEDULER)
def test_find_response(self):
response = FindResponse(FindResultCode.OK)
scheduler = MagicMock()
scheduler.find.return_value = response
handler = SchedulerHandler()
handler._schedulers["foo"] = scheduler
actual_response = handler.find(FindRequest(Locator(), "foo"))
assert_that(actual_response, is_(same_instance(response)))
def test_find_timeout(self, wait_fn, client_class):
client_class.side_effect = self.create_fake_client
client = MagicMock()
response = FindResponse(FindResultCode.OK)
client.find.return_value = response
self._clients["baz"] = client
scheduler = BranchScheduler("foo", 9)
scheduler.configure([ChildInfo(id="baz", address="baz")])
wait_fn.return_value = set(), set()
response = scheduler.find(FindRequest())
assert_that(response.result, is_(FindResultCode.NOT_FOUND))
# must shutdown to join the futures since the patch lifecycle
# ends when this method returns
self._threadpool.shutdown()
def find(self, request):
"""Find the specified resource.
:type request: FindRequest
:rtype: FindResponse
"""
futures = []
for scheduler in self._schedulers:
future = self._threadpool.submit(
self._find_worker, scheduler.address, scheduler.port,
scheduler.id, copy.deepcopy(request))
futures.append(future)
done, not_done = concurrent.futures.wait(futures, timeout=FIND_TIMEOUT)
self._logger.info("Find responses received: %d, timed out: %d",
len(done), len(not_done))
for future in done:
response = future.result()
if response.result == FindResultCode.OK:
return response
return FindResponse(FindResultCode.NOT_FOUND)
def find(self, request):
self.find_reqs.append(request)
return FindResponse(FindResultCode.NOT_FOUND)
