def convert_with_links(rpc_portgroup, fields=None, sanitize=True):
"""Add links to the portgroup."""
portgroup = api_utils.object_to_dict(
rpc_portgroup,
link_resource='portgroups',
fields=('address', 'extra', 'internal_info', 'mode', 'name',
'properties', 'standalone_ports_supported'))
api_utils.populate_node_uuid(rpc_portgroup, portgroup)
url = api.request.public_url
portgroup['ports'] = [
link.make_link('self', url, 'portgroups',
rpc_portgroup.uuid + "/ports"),
link.make_link('bookmark',
url,
'portgroups',
rpc_portgroup.uuid + "/ports",
bookmark=True)
]
if fields is not None:
api_utils.check_for_invalid_fields(fields, portgroup)
if not sanitize:
return portgroup
api_utils.sanitize_dict(portgroup, fields)
return portgroup
def convert_with_links(rpc_allocation, fields=None, sanitize=True):
allocation = api_utils.object_to_dict(
rpc_allocation,
link_resource='allocations',
fields=(
'candidate_nodes',
'extra',
'last_error',
'name',
'owner',
'resource_class',
'state',
'traits'
)
)
try:
api_utils.populate_node_uuid(rpc_allocation, allocation)
except exception.NodeNotFound:
allocation['node_uuid'] = None
if fields is not None:
api_utils.check_for_invalid_fields(fields, set(allocation))
if sanitize:
allocation_sanitize(allocation, fields)
return allocation
def convert_with_links(rpc_port, fields=None, sanitize=True):
port = api_utils.object_to_dict(
rpc_port,
link_resource='ports',
fields=(
'address',
'extra',
'internal_info',
'is_smartnic',
'local_link_connection',
'physical_network',
'pxe_enabled',
)
)
api_utils.populate_node_uuid(rpc_port, port)
if rpc_port.portgroup_id:
pg = objects.Portgroup.get(api.request.context, rpc_port.portgroup_id)
port['portgroup_uuid'] = pg.uuid
else:
port['portgroup_uuid'] = None
_validate_fields(port, fields)
if not sanitize:
return port
port_sanitize(port, fields=fields)
return port
def convert_with_links(rpc_bios, node_uuid):
"""Build a dict containing a bios setting value."""
bios = api_utils.object_to_dict(
rpc_bios,
include_uuid=False,
fields=('name', 'value'),
link_resource='nodes',
link_resource_args="%s/bios/%s" % (node_uuid, rpc_bios.name),
)
return bios
def convert_with_links(rpc_bios, node_uuid, detail=None, fields=None):
"""Build a dict containing a bios setting value."""
if detail:
fields = _DEFAULT_FIELDS_WITH_REGISTRY
bios = api_utils.object_to_dict(
rpc_bios,
include_uuid=False,
fields=fields,
link_resource='nodes',
link_resource_args="%s/bios/%s" % (node_uuid, rpc_bios.name),
)
return bios
def convert_with_links(rpc_conductor, fields=None, sanitize=True):
conductor = api_utils.object_to_dict(
rpc_conductor,
include_uuid=False,
fields=('hostname', 'conductor_group', 'drivers'),
link_resource='conductors',
link_resource_args=rpc_conductor.hostname)
conductor['alive'] = not timeutils.is_older_than(
rpc_conductor.updated_at, CONF.conductor.heartbeat_timeout)
if fields is not None:
api_utils.check_for_invalid_fields(fields, conductor)
if sanitize:
api_utils.sanitize_dict(conductor, fields)
return conductor
def convert_with_links(rpc_template, fields=None, sanitize=True):
"""Add links to the deploy template."""
template = api_utils.object_to_dict(
rpc_template,
fields=('name', 'extra'),
link_resource='deploy_templates',
)
template['steps'] = list(convert_steps(rpc_template.steps))
if fields is not None:
api_utils.check_for_invalid_fields(fields, template)
if sanitize:
template_sanitize(template, fields)
return template
def convert_with_links(rpc_connector, fields=None, sanitize=True):
connector = api_utils.object_to_dict(rpc_connector,
link_resource='volume/connectors',
fields=('connector_id', 'extra',
'type'))
api_utils.populate_node_uuid(rpc_connector, connector)
if fields is not None:
api_utils.check_for_invalid_fields(fields, connector)
if not sanitize:
return connector
api_utils.sanitize_dict(connector, fields)
return connector
def convert_with_links(rpc_target, fields=None, sanitize=True):
target = api_utils.object_to_dict(rpc_target,
link_resource='volume/targets',
fields=('boot_index', 'extra',
'properties', 'volume_id',
'volume_type'))
api_utils.populate_node_uuid(rpc_target, target)
if fields is not None:
api_utils.check_for_invalid_fields(fields, target)
if not sanitize:
return target
api_utils.sanitize_dict(target, fields)
return target
def convert_with_links(rpc_chassis, fields=None, sanitize=True):
chassis = api_utils.object_to_dict(rpc_chassis,
fields=('description', 'extra'),
link_resource='chassis')
url = api.request.public_url
chassis['nodes'] = [
link.make_link('self', url, 'chassis', rpc_chassis.uuid + "/nodes"),
link.make_link('bookmark',
url,
'chassis',
rpc_chassis.uuid + "/nodes",
bookmark=True)
],
if fields is not None:
api_utils.check_for_invalid_fields(fields, chassis)
if sanitize:
api_utils.sanitize_dict(chassis, fields)
return chassis
