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(portgroup, url, fields=None):
"""Add links to the portgroup."""
if fields is None:
portgroup.ports = [
link.make_link('self', url, 'portgroups',
portgroup.uuid + "/ports"),
link.make_link('bookmark',
url,
'portgroups',
portgroup.uuid + "/ports",
bookmark=True)
]
# never expose the node_id attribute
portgroup.node_id = atypes.Unset
portgroup.links = [
link.make_link('self', url, 'portgroups', portgroup.uuid),
link.make_link('bookmark',
url,
'portgroups',
portgroup.uuid,
bookmark=True)
]
return portgroup
def _convert_with_links(conductor, url, fields=None):
conductor.links = [link.make_link('self', url, 'conductors',
conductor.hostname),
link.make_link('bookmark', url, 'conductors',
conductor.hostname,
bookmark=True)]
return conductor
def _convert_with_links(bios, node_uuid, url):
"""Add links to the bios setting."""
name = bios.name
bios.links = [link.make_link('self', url, 'nodes',
"%s/bios/%s" % (node_uuid, name)),
link.make_link('bookmark', url, 'nodes',
"%s/bios/%s" % (node_uuid, name),
bookmark=True)]
return bios
def _convert_with_links(allocation, url):
"""Add links to the allocation."""
# This field is only used in POST, never return it.
allocation.node = atypes.Unset
allocation.links = [
link.make_link('self', url, 'allocations', allocation.uuid),
link.make_link('bookmark', url, 'allocations',
allocation.uuid, bookmark=True)
]
return allocation
def _convert_with_links(template, url, fields=None):
template.links = [
link.make_link('self', url, 'deploy_templates', template.uuid),
link.make_link('bookmark',
url,
'deploy_templates',
template.uuid,
bookmark=True)
]
return template
def _convert_with_links(connector, url):
connector.links = [
link.make_link('self', url, 'volume/connectors', connector.uuid),
link.make_link('bookmark',
url,
'volume/connectors',
connector.uuid,
bookmark=True)
]
return connector
def _convert_with_links(target, url):
target.links = [
link.make_link('self', url, 'volume/targets', target.uuid),
link.make_link('bookmark',
url,
'volume/targets',
target.uuid,
bookmark=True)
]
return target
def get_next(collection, limit, url=None, key_field='uuid', **kwargs):
"""Return a link to the next subset of the collection."""
if not has_next(collection, limit):
return None
fields = kwargs.pop('fields', None)
# NOTE(saga): If fields argument is present in kwargs and not None. It
# is a list so convert it into a comma seperated string.
if fields:
kwargs['fields'] = ','.join(fields)
q_args = ''.join(['%s=%s&' % (key, kwargs[key]) for key in kwargs])
last_item = collection[-1]
# handle items which are either objects or dicts
if hasattr(last_item, key_field):
marker = getattr(last_item, key_field)
else:
marker = last_item.get(key_field)
next_args = '?%(args)slimit=%(limit)d&marker=%(marker)s' % {
'args': q_args,
'limit': limit,
'marker': marker
}
return link.make_link('next', api.request.public_url, url,
next_args)['href']
def default_version():
"""Return a dict representing the current default version
id: The ID of the (major) version, also acts as the release number
links: A list containing one link that points to the current version
of the API
status: Status of the version, one of CURRENT, SUPPORTED, DEPRECATED
min_version: The current, maximum supported (major.minor) version of API.
version: Minimum supported (major.minor) version of API.
"""
# NOTE(dtantsur): avoid circular imports
from ironic.api.controllers.v1 import versions
return {
'id':
ID_VERSION1,
'links': [
link.make_link('self',
api.request.public_url,
ID_VERSION1,
'',
bookmark=True)
],
'status':
'CURRENT',
'min_version':
versions.min_version_string(),
'version':
versions.max_version_string()
}
def convert_with_links(cls, rpc_port, fields=None, sanitize=True):
port = Port(**rpc_port.as_dict())
port._validate_fields(fields)
url = api.request.public_url
port.links = [
link.make_link('self', url, 'ports', port.uuid),
link.make_link('bookmark', url, 'ports', port.uuid, bookmark=True)
]
if not sanitize:
return port
port.sanitize(fields=fields)
return port
def _convert_with_links(chassis, url, fields=None):
if fields is None:
chassis.nodes = [
link.make_link('self', url, 'chassis',
chassis.uuid + "/nodes"),
link.make_link('bookmark',
url,
'chassis',
chassis.uuid + "/nodes",
bookmark=True)
]
chassis.links = [
link.make_link('self', url, 'chassis', chassis.uuid),
link.make_link('bookmark',
url,
'chassis',
chassis.uuid,
bookmark=True)
]
return chassis
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
def convert(node_ident=None):
url = api.request.public_url
volume = Volume()
if node_ident:
resource = 'nodes'
args = '%s/volume/' % node_ident
else:
resource = 'volume'
args = ''
volume.links = [
link.make_link('self', url, resource, args),
link.make_link('bookmark', url, resource, args, bookmark=True)
]
volume.connectors = [
link.make_link('self', url, resource, args + 'connectors'),
link.make_link('bookmark',
url,
resource,
args + 'connectors',
bookmark=True)
]
volume.targets = [
link.make_link('self', url, resource, args + 'targets'),
link.make_link('bookmark',
url,
resource,
args + 'targets',
bookmark=True)
]
return volume
def get_next(self, limit, url=None, **kwargs):
"""Return a link to the next subset of the collection."""
if not self.has_next(limit):
return atypes.Unset
resource_url = url or self._type
fields = kwargs.pop('fields', None)
# NOTE(saga): If fields argument is present in kwargs and not None. It
# is a list so convert it into a comma seperated string.
if fields:
kwargs['fields'] = ','.join(fields)
q_args = ''.join(['%s=%s&' % (key, kwargs[key]) for key in kwargs])
next_args = '?%(args)slimit=%(limit)d&marker=%(marker)s' % {
'args': q_args,
'limit': limit,
'marker': getattr(self.collection[-1], self.get_key_field())
}
return link.make_link('next', api.request.public_url, resource_url,
next_args)['href']
def v1():
v1 = {
'id':
"v1",
'links': [
link.make_link('self',
api.request.public_url,
'v1',
'',
bookmark=True),
link.make_link('describedby',
'https://docs.openstack.org',
'/ironic/latest/contributor/',
'webapi.html',
bookmark=True,
type='text/html')
],
'media_types': {
'base': 'application/json',
'type': 'application/vnd.openstack.ironic.v1+json'
},
'chassis': [
link.make_link('self', api.request.public_url, 'chassis', ''),
link.make_link('bookmark',
api.request.public_url,
'chassis',
'',
bookmark=True)
],
'nodes': [
link.make_link('self', api.request.public_url, 'nodes', ''),
link.make_link('bookmark',
api.request.public_url,
'nodes',
'',
bookmark=True)
],
'ports': [
link.make_link('self', api.request.public_url, 'ports', ''),
link.make_link('bookmark',
api.request.public_url,
'ports',
'',
bookmark=True)
],
'drivers': [
link.make_link('self', api.request.public_url, 'drivers', ''),
link.make_link('bookmark',
api.request.public_url,
'drivers',
'',
bookmark=True)
],
'version':
version.default_version()
}
if utils.allow_portgroups():
v1['portgroups'] = [
link.make_link('self', api.request.public_url, 'portgroups', ''),
link.make_link('bookmark',
api.request.public_url,
'portgroups',
'',
bookmark=True)
]
if utils.allow_volume():
v1['volume'] = [
link.make_link('self', api.request.public_url, 'volume', ''),
link.make_link('bookmark',
api.request.public_url,
'volume',
'',
bookmark=True)
]
if utils.allow_ramdisk_endpoints():
v1['lookup'] = [
link.make_link('self', api.request.public_url, 'lookup', ''),
link.make_link('bookmark',
api.request.public_url,
'lookup',
'',
bookmark=True)
]
v1['heartbeat'] = [
link.make_link('self', api.request.public_url, 'heartbeat', ''),
link.make_link('bookmark',
api.request.public_url,
'heartbeat',
'',
bookmark=True)
]
if utils.allow_expose_conductors():
v1['conductors'] = [
link.make_link('self', api.request.public_url, 'conductors', ''),
link.make_link('bookmark',
api.request.public_url,
'conductors',
'',
bookmark=True)
]
if utils.allow_allocations():
v1['allocations'] = [
link.make_link('self', api.request.public_url, 'allocations', ''),
link.make_link('bookmark',
api.request.public_url,
'allocations',
'',
bookmark=True)
]
if utils.allow_expose_events():
v1['events'] = [
link.make_link('self', api.request.public_url, 'events', ''),
link.make_link('bookmark',
api.request.public_url,
'events',
'',
bookmark=True)
]
if utils.allow_deploy_templates():
v1['deploy_templates'] = [
link.make_link('self', api.request.public_url, 'deploy_templates',
''),
link.make_link('bookmark',
api.request.public_url,
'deploy_templates',
'',
bookmark=True)
]
return v1
def convert_with_links(name, hosts, detail=False, interface_info=None):
"""Convert driver/hardware type info to an API-serializable object.
:param name: name of a hardware type.
:param hosts: list of conductor hostnames driver is active on.
:param detail: boolean, whether to include detailed info, such as
the 'type' field and default/enabled interfaces fields.
:param interface_info: optional list of dicts of hardware interface
info.
:returns: API-serializable driver object.
"""
driver = Driver()
driver.name = name
driver.hosts = hosts
driver.links = [
link.make_link('self', api.request.public_url, 'drivers', name),
link.make_link('bookmark',
api.request.public_url,
'drivers',
name,
bookmark=True)
]
if api_utils.allow_links_node_states_and_driver_properties():
driver.properties = [
link.make_link('self', api.request.public_url, 'drivers',
name + "/properties"),
link.make_link('bookmark',
api.request.public_url,
'drivers',
name + "/properties",
bookmark=True)
]
if api_utils.allow_dynamic_drivers():
# NOTE(dtantsur): only dynamic drivers (based on hardware types)
# are supported starting with the Rocky release.
driver.type = 'dynamic'
if detail:
if interface_info is None:
# TODO(jroll) objectify this
interface_info = (
api.request.dbapi.list_hardware_type_interfaces([name
]))
for iface_type in driver_base.ALL_INTERFACES:
default = None
enabled = set()
for iface in interface_info:
if iface['interface_type'] == iface_type:
iface_name = iface['interface_name']
enabled.add(iface_name)
# NOTE(jroll) this assumes the default is the same
# on all conductors
if iface['default']:
default = iface_name
default_key = 'default_%s_interface' % iface_type
enabled_key = 'enabled_%s_interfaces' % iface_type
setattr(driver, default_key, default)
setattr(driver, enabled_key, list(enabled))
hide_fields_in_newer_versions(driver)
return driver
def convert():
v1 = V1()
v1.id = "v1"
v1.links = [
link.make_link('self',
api.request.public_url,
'v1',
'',
bookmark=True),
link.make_link('describedby',
'https://docs.openstack.org',
'/ironic/latest/contributor/',
'webapi.html',
bookmark=True,
type='text/html')
]
v1.media_types = [
MediaType('application/json',
'application/vnd.openstack.ironic.v1+json')
]
v1.chassis = [
link.make_link('self', api.request.public_url, 'chassis', ''),
link.make_link('bookmark',
api.request.public_url,
'chassis',
'',
bookmark=True)
]
v1.nodes = [
link.make_link('self', api.request.public_url, 'nodes', ''),
link.make_link('bookmark',
api.request.public_url,
'nodes',
'',
bookmark=True)
]
v1.ports = [
link.make_link('self', api.request.public_url, 'ports', ''),
link.make_link('bookmark',
api.request.public_url,
'ports',
'',
bookmark=True)
]
if utils.allow_portgroups():
v1.portgroups = [
link.make_link('self', api.request.public_url, 'portgroups',
''),
link.make_link('bookmark',
api.request.public_url,
'portgroups',
'',
bookmark=True)
]
v1.drivers = [
link.make_link('self', api.request.public_url, 'drivers', ''),
link.make_link('bookmark',
api.request.public_url,
'drivers',
'',
bookmark=True)
]
if utils.allow_volume():
v1.volume = [
link.make_link('self', api.request.public_url, 'volume', ''),
link.make_link('bookmark',
api.request.public_url,
'volume',
'',
bookmark=True)
]
if utils.allow_ramdisk_endpoints():
v1.lookup = [
link.make_link('self', api.request.public_url, 'lookup', ''),
link.make_link('bookmark',
api.request.public_url,
'lookup',
'',
bookmark=True)
]
v1.heartbeat = [
link.make_link('self', api.request.public_url, 'heartbeat',
''),
link.make_link('bookmark',
api.request.public_url,
'heartbeat',
'',
bookmark=True)
]
if utils.allow_expose_conductors():
v1.conductors = [
link.make_link('self', api.request.public_url, 'conductors',
''),
link.make_link('bookmark',
api.request.public_url,
'conductors',
'',
bookmark=True)
]
if utils.allow_allocations():
v1.allocations = [
link.make_link('self', api.request.public_url, 'allocations',
''),
link.make_link('bookmark',
api.request.public_url,
'allocations',
'',
bookmark=True)
]
if utils.allow_expose_events():
v1.events = [
link.make_link('self', api.request.public_url, 'events', ''),
link.make_link('bookmark',
api.request.public_url,
'events',
'',
bookmark=True)
]
if utils.allow_deploy_templates():
v1.deploy_templates = [
link.make_link('self', api.request.public_url,
'deploy_templates', ''),
link.make_link('bookmark',
api.request.public_url,
'deploy_templates',
'',
bookmark=True)
]
v1.version = version.default_version()
return v1