def obj_create(self, bundle, **kwargs):
request = bundle.request
self.is_valid(bundle)
if bundle.errors:
raise ImmediateHttpResponse(response=self.error_response(
bundle.request, bundle.errors[self._meta.resource_name]))
# Set up an errors dict in the bundle to allow us to carry
# hydration errors through to validation.
setattr(bundle, 'data_errors', defaultdict(list))
bundle.data['content_type'] = ContentType.objects.get_for_model(
KIND_TO_KLASS[bundle.data['kind']]).natural_key()
# Should really only be doing one validation pass, but this works
# OK for now. It's better than raising a 404 or duplicating the
# filesystem validation failure if it doesn't exist, anyhow.
self.is_valid(bundle)
targets, command = JobSchedulerClient.create_targets([bundle.data])
if request.method == 'POST':
raise custom_response(
self, request, http.HttpAccepted, {
'command':
dehydrate_command(command),
'target':
self.full_dehydrate(self.build_bundle(obj=targets[0])).data
})
def obj_update(self, bundle, **kwargs):
if "pk" in kwargs:
return super(LNetConfigurationResource,
self).obj_update(bundle, **kwargs)
lnet_configurations_data = bundle.data.get("objects", [bundle.data])
lnet_configuration = []
for lnet_configuration_data in lnet_configurations_data:
lnet_configuration.append({
"host_id":
lnet_configuration_data["host"]["id"],
"state":
lnet_configuration_data["state"]
})
command_id = JobSchedulerClient.update_lnet_configuration(
lnet_configuration)
try:
command = Command.objects.get(pk=command_id)
except ObjectDoesNotExist:
command = None
raise custom_response(self, bundle.request, http.HttpAccepted,
{"command": dehydrate_command(command)})
def _update_corosync_configuration(self, corosync_configuration, request, **kwargs):
network_interface_ids = [resolve(interwork_interface)[2]['pk'] for interwork_interface in corosync_configuration['network_interfaces']]
return self.BulkActionResult(dehydrate_command(JobSchedulerClient.update_corosync_configuration(corosync_configuration_id=corosync_configuration['id'],
mcast_port=corosync_configuration['mcast_port'],
network_interface_ids=network_interface_ids)),
None, None)
def patch_list(self, request, **kwargs):
"""
Specialization of patch_list to do bulk target creation in a single RPC to job_scheduler (and
consequently in a single command).
"""
deserialized = self.deserialize(request, request.raw_post_data, format=request.META.get('CONTENT_TYPE', 'application/json'))
if "objects" not in deserialized:
raise BadRequest("Invalid data sent.")
if len(deserialized["objects"]) and 'put' not in self._meta.detail_allowed_methods:
raise ImmediateHttpResponse(response=http.HttpMethodNotAllowed())
# If any of the included targets is not a creation, then
# skip to a normal PATCH instead of this special case one
for target_data in deserialized['objects']:
if 'id' in target_data or 'resource_uri' in target_data:
super(TargetResource, self).patch_list(request, **kwargs)
# Validate and prepare each target dict for consumption by job_scheduler
for target_data in deserialized['objects']:
data = self.alter_deserialized_detail_data(request, target_data)
bundle = self.build_bundle(data=dict_strip_unicode_keys(data))
bundle.request = request
self.is_valid(bundle)
target_data['content_type'] = ContentType.objects.get_for_model(KIND_TO_KLASS[target_data['kind']]).natural_key()
targets, command = JobSchedulerClient.create_targets(deserialized['objects'])
raise custom_response(self, request, http.HttpAccepted,
{'command': dehydrate_command(command),
'targets': [self.get_resource_uri(target) for target in targets]})
def _pool_delete(self, request, obj_list):
commands = []
for obj in obj_list:
command_id = JobSchedulerClient.delete_ostpool(obj.id)
command = Command.objects.get(pk=command_id)
commands.append(dehydrate_command(command))
raise custom_response(self, request, http.HttpAccepted,
{"commands": commands})
def obj_create(self, bundle, **kwargs):
request = bundle.request
ostpool_id, command_id = JobSchedulerClient.create_ostpool(bundle.data)
command = Command.objects.get(pk=command_id)
raise custom_response(self, request, http.HttpAccepted,
{"command": dehydrate_command(command)})
def obj_create(self, bundle, **kwargs):
command_id = JobSchedulerClient.configure_stratagem(bundle.data)
try:
command = Command.objects.get(pk=command_id)
except ObjectDoesNotExist:
command = None
raise custom_response(self, bundle.request, http.HttpAccepted,
{"command": dehydrate_command(command)})
def obj_update(self, bundle, **kwargs):
try:
obj = self.obj_get(bundle, **kwargs)
except ObjectDoesNotExist:
raise NotFound(
"A model instance matching the provided arguments could not be found."
)
command_id = JobSchedulerClient.update_ostpool(bundle.data)
command = Command.objects.get(pk=command_id)
raise custom_response(self, bundle.request, http.HttpAccepted,
{"command": dehydrate_command(command)})
def obj_create(self, bundle, request=None, **kwargs):
filesystem_id, command_id = JobSchedulerClient.create_filesystem(
bundle.data)
filesystem = ManagedFilesystem.objects.get(pk=filesystem_id)
command = Command.objects.get(pk=command_id)
fs_bundle = self.full_dehydrate(self.build_bundle(obj=filesystem))
filesystem_data = self.alter_detail_data_to_serialize(
request, fs_bundle).data
raise custom_response(self, request, http.HttpAccepted, {
'command': dehydrate_command(command),
'filesystem': filesystem_data
})
def obj_create(self, bundle, **kwargs):
(_, fs_id) = get_fs_id(bundle)
mdts = list(
ManagedMdt.objects.filter(
filesystem_id=fs_id,
active_mount_id__isnull=False).values_list("id", flat=True))
command_id = JobSchedulerClient.run_stratagem(mdts, fs_id, bundle.data)
try:
command = Command.objects.get(pk=command_id)
except ObjectDoesNotExist:
command = None
raise custom_response(self, bundle.request, http.HttpAccepted,
{"command": dehydrate_command(command)})
def _update_corosync_configuration(self, corosync_configuration, request, **kwargs):
network_interface_ids = [
resolve(interwork_interface)[2]["pk"]
for interwork_interface in corosync_configuration["network_interfaces"]
]
return self.BulkActionResult(
dehydrate_command(
JobSchedulerClient.update_corosync_configuration(
corosync_configuration_id=corosync_configuration["id"],
mcast_port=corosync_configuration["mcast_port"],
network_interface_ids=network_interface_ids,
)
),
None,
None,
)
def _create_host(self, address, data, request):
# Resolve a server profile URI to a record
profile = ServerProfileResource().get_via_uri(data["server_profile"], request)
host, command = JobSchedulerClient.create_host_ssh(server_profile=profile.name, **_host_params(data, address))
# TODO: Could simplify this by adding a 'command' key to the
# bundle, then optionally handling dehydrating that
# in super.alter_detail_data_to_serialize. That way could
# return from this method avoiding all this extra code, and
# providing a central handling for all things that migth have
# a command argument. NB: not tested, and not part of any ticket
object = {
"command": dehydrate_command(command),
"host": self.alter_detail_data_to_serialize(None, self.full_dehydrate(self.build_bundle(obj=host))).data,
}
return self.BulkActionResult(object, None, None)
def obj_create(self, bundle, request=None, **kwargs):
if 'objects' in bundle.data:
nids_data = bundle.data['objects']
else:
nids_data = [bundle.data]
for nid_data in nids_data:
nid_data['network_interface'] = NetworkInterfaceResource(
).get_via_uri(nid_data['network_interface']).id
command_id = JobSchedulerClient.update_nids(nids_data)
try:
command = Command.objects.get(pk=command_id)
except ObjectDoesNotExist:
command = None
raise custom_response(self, request, http.HttpAccepted,
{'command': dehydrate_command(command)})
def obj_create(self, bundle, **kwargs):
request = bundle.request
if "objects" in bundle.data:
nids_data = bundle.data["objects"]
else:
nids_data = [bundle.data]
for nid_data in nids_data:
nid_data["network_interface"] = (
NetworkInterfaceResource().get_via_uri(nid_data["network_interface"], bundle.request).id
)
command_id = JobSchedulerClient.update_nids(nids_data)
try:
command = Command.objects.get(pk=command_id)
except ObjectDoesNotExist:
command = None
raise custom_response(self, request, http.HttpAccepted, {"command": dehydrate_command(command)})
def _test_host_contact(self, data, request, **kwargs):
return self.BulkActionResult(
dehydrate_command(
JobSchedulerClient.test_host_contact(
**_host_params(data))), None, None)
