def test_returns_one_of_the_discovered(self):
self.assertThat(
get_best_discovered_result(({
factory.make_name("system_id"):
sentinel.first,
factory.make_name("system_id"):
sentinel.second,
}, {})), MatchesAny(Is(sentinel.first), Is(sentinel.second)))
def discover_and_sync_pod(self):
"""Discover and sync the pod information."""
def update_db(result):
discovered_pod, discovered = result
# When called with an instance that has no name, be sure to set
# it before going any further. If this is a new instance this will
# also create it in the database.
if not self.instance.name:
self.instance.set_random_name()
self.instance.sync(discovered_pod, self.request.user)
# Save which rack controllers can route and which cannot.
discovered_rack_ids = [
rack_id for rack_id, _ in discovered[0].items()
]
for rack_controller in RackController.objects.all():
routable = rack_controller.system_id in discovered_rack_ids
bmc_route_model = BMCRoutableRackControllerRelationship
relation, created = (bmc_route_model.objects.get_or_create(
bmc=self.instance.as_bmc(),
rack_controller=rack_controller,
defaults={'routable': routable}))
if not created and relation.routable != routable:
relation.routable = routable
relation.save()
return self.instance
if isInIOThread():
# Running in twisted reactor, do the work inside the reactor.
d = discover_pod(self.instance.power_type,
self.instance.power_parameters,
pod_id=self.instance.id,
name=self.instance.name)
d.addCallback(lambda discovered:
(get_best_discovered_result(discovered), discovered))
def catch_no_racks(result):
discovered_pod, discovered = result
if discovered_pod is None:
raise PodProblem(
"Unable to start the pod discovery process. "
"No rack controllers connected.")
return discovered_pod, discovered
def wrap_errors(failure):
if failure.check(PodProblem):
return failure
else:
raise PodProblem(str(failure.value))
d.addCallback(catch_no_racks)
d.addCallback(partial(deferToDatabase, transactional(update_db)))
d.addErrback(wrap_errors)
return d
else:
# Perform the actions inside the executing thread.
try:
discovered = discover_pod(self.instance.power_type,
self.instance.power_parameters,
pod_id=self.instance.id,
name=self.instance.name)
except Exception as exc:
raise PodProblem(str(exc)) from exc
# Use the first discovered pod object. All other objects are
# ignored. The other rack controllers that also provided a result
# can route to the pod.
try:
discovered_pod = get_best_discovered_result(discovered)
except Exception as error:
raise PodProblem(str(error))
if discovered_pod is None:
raise PodProblem("Unable to start the pod discovery process. "
"No rack controllers connected.")
return update_db((discovered_pod, discovered))
def get_projects(self, params):
"""Return projects from the specified pod."""
pod_type = params.pop("type")
results = yield discover_pod_projects(pod_type, params)
projects = yield get_best_discovered_result(results)
returnValue([attr.asdict(project) for project in projects])
def test_returns_None(self):
self.assertIsNone(get_best_discovered_result(({}, {})))
def discover_and_sync_pod(self):
"""Discover and sync the pod information."""
def update_db(result):
discovered_pod, discovered = result
if self.request is not None:
user = self.request.user
else:
user = self.user
# If this is a new instance it will be stored in the database
# at the end of sync.
self.instance.sync(discovered_pod, user)
# Save which rack controllers can route and which cannot.
discovered_rack_ids = [
rack_id for rack_id, _ in discovered[0].items()
]
for rack_controller in RackController.objects.all():
routable = rack_controller.system_id in discovered_rack_ids
bmc_route_model = BMCRoutableRackControllerRelationship
relation, created = bmc_route_model.objects.get_or_create(
bmc=self.instance.as_bmc(),
rack_controller=rack_controller,
defaults={"routable": routable},
)
if not created and relation.routable != routable:
relation.routable = routable
relation.save()
return self.instance
if isInIOThread():
# Running in twisted reactor, do the work inside the reactor.
d = discover_pod(
self.instance.power_type,
self.instance.power_parameters,
pod_id=self.instance.id,
name=self.instance.name,
)
d.addCallback(lambda discovered: (
get_best_discovered_result(discovered),
discovered,
))
def catch_no_racks(result):
discovered_pod, discovered = result
if discovered_pod is None:
raise PodProblem(
"Unable to start the pod discovery process. "
"No rack controllers connected.")
return discovered_pod, discovered
def wrap_errors(failure):
if failure.check(PodProblem):
return failure
else:
log.err(failure, "Failed to discover pod.")
raise PodProblem(str(failure.value))
d.addCallback(catch_no_racks)
d.addCallback(partial(deferToDatabase, transactional(update_db)))
d.addCallback(request_commissioning_results)
d.addErrback(wrap_errors)
return d
else:
# Perform the actions inside the executing thread.
try:
discovered = discover_pod(
self.instance.power_type,
self.instance.power_parameters,
pod_id=self.instance.id,
name=self.instance.name,
)
except Exception as exc:
raise PodProblem(str(exc)) from exc
# Use the first discovered pod object. All other objects are
# ignored. The other rack controllers that also provided a result
# can route to the pod.
try:
discovered_pod = get_best_discovered_result(discovered)
except Exception as error:
raise PodProblem(str(error))
if discovered_pod is None:
raise PodProblem("Unable to start the pod discovery process. "
"No rack controllers connected.")
update_db((discovered_pod, discovered))
# The data isn't committed to the database until the transaction is
# complete. The commissioning results must be sent after the
# transaction completes so the metadata server can process the
# data.
post_commit_do(
reactor.callLater,
0,
request_commissioning_results,
self.instance,
)
# Run commissioning request here
return self.instance
