def post(self, portgroup):
"""Create a new portgroup.
:param portgroup: a portgroup within the request body.
"""
if not api_utils.allow_portgroups():
raise exception.NotFound()
context = api.request.context
api_utils.check_policy('baremetal:portgroup:create')
if self.parent_node_ident:
raise exception.OperationNotPermitted()
if (not api_utils.allow_portgroup_mode_properties()
and (portgroup.get('mode') or portgroup.get('properties'))):
raise exception.NotAcceptable()
if (portgroup.get('name')
and not api_utils.is_valid_logical_name(portgroup['name'])):
error_msg = _("Cannot create portgroup with invalid name "
"'%(name)s'") % {
'name': portgroup['name']
}
raise exception.ClientSideError(
error_msg, status_code=http_client.BAD_REQUEST)
api_utils.handle_post_port_like_extra_vif(portgroup)
# NOTE(yuriyz): UUID is mandatory for notifications payload
if not portgroup.get('uuid'):
portgroup['uuid'] = uuidutils.generate_uuid()
node = api_utils.replace_node_uuid_with_id(portgroup)
new_portgroup = objects.Portgroup(context, **portgroup)
notify.emit_start_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid)
with notify.handle_error_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid):
new_portgroup.create()
notify.emit_end_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid)
# Set the HTTP Location Header
api.response.location = link.build_url('portgroups',
new_portgroup.uuid)
return convert_with_links(new_portgroup)
def post(self, connector):
"""Create a new volume connector.
:param connector: a volume connector within the request body.
:returns: API-serializable volume connector object.
:raises: OperationNotPermitted if accessed with specifying a parent
node.
:raises: VolumeConnectorTypeAndIdAlreadyExists if a volume
connector already exists with the same type and connector_id
:raises: VolumeConnectorAlreadyExists if a volume connector with the
same UUID already exists
"""
context = api.request.context
owner = None
lessee = None
raise_node_not_found = False
node_uuid = connector.get('node_uuid')
try:
node = api_utils.replace_node_uuid_with_id(connector)
owner = node.owner
lessee = node.lessee
except exception.NotFound:
raise_node_not_found = True
api_utils.check_owner_policy('node', 'baremetal:volume:create',
owner, lessee=lessee, conceal_node=False)
if raise_node_not_found:
raise exception.InvalidInput(fieldname='node_uuid',
value=node_uuid)
if self.parent_node_ident:
raise exception.OperationNotPermitted()
# NOTE(hshiina): UUID is mandatory for notification payload
if not connector.get('uuid'):
connector['uuid'] = uuidutils.generate_uuid()
new_connector = objects.VolumeConnector(context, **connector)
notify.emit_start_notification(context, new_connector, 'create',
node_uuid=node.uuid)
with notify.handle_error_notification(context, new_connector,
'create',
node_uuid=node.uuid):
new_connector.create()
notify.emit_end_notification(context, new_connector, 'create',
node_uuid=node.uuid)
# Set the HTTP Location Header
api.response.location = link.build_url('volume/connectors',
new_connector.uuid)
return convert_with_links(new_connector)
def post(self, target):
"""Create a new volume target.
:param target: a volume target within the request body.
:returns: API-serializable volume target object.
:raises: OperationNotPermitted if accessed with specifying a parent
node.
:raises: VolumeTargetBootIndexAlreadyExists if a volume target already
exists with the same node ID and boot index
:raises: VolumeTargetAlreadyExists if a volume target with the same
UUID exists
"""
context = api.request.context
api_utils.check_policy('baremetal:volume:create')
if self.parent_node_ident:
raise exception.OperationNotPermitted()
# NOTE(hshiina): UUID is mandatory for notification payload
if not target.get('uuid'):
target['uuid'] = uuidutils.generate_uuid()
node = api_utils.replace_node_uuid_with_id(target)
new_target = objects.VolumeTarget(context, **target)
notify.emit_start_notification(context,
new_target,
'create',
node_uuid=node.uuid)
with notify.handle_error_notification(context,
new_target,
'create',
node_uuid=node.uuid):
new_target.create()
notify.emit_end_notification(context,
new_target,
'create',
node_uuid=node.uuid)
# Set the HTTP Location Header
api.response.location = link.build_url('volume/targets',
new_target.uuid)
return convert_with_links(new_target)
def post(self, portgroup):
"""Create a new portgroup.
:param portgroup: a portgroup within the request body.
"""
if not api_utils.allow_portgroups():
raise exception.NotFound()
raise_node_not_found = False
node = None
owner = None
lessee = None
node_uuid = portgroup.get('node_uuid')
try:
# The replace_node_uuid_with_id also checks access to the node
# and will raise an exception if access is not permitted.
node = api_utils.replace_node_uuid_with_id(portgroup)
owner = node.owner
lessee = node.lessee
except exception.NotFound:
raise_node_not_found = True
# While the rule is for the port, the base object that controls access
# is the node.
api_utils.check_owner_policy('node',
'baremetal:portgroup:create',
owner,
lessee=lessee,
conceal_node=False)
if raise_node_not_found:
# Delayed raise of NodeNotFound because we want to check
# the access policy first.
raise exception.NodeNotFound(node=node_uuid,
code=http_client.BAD_REQUEST)
context = api.request.context
if self.parent_node_ident:
raise exception.OperationNotPermitted()
if (not api_utils.allow_portgroup_mode_properties()
and (portgroup.get('mode') or portgroup.get('properties'))):
raise exception.NotAcceptable()
if (portgroup.get('name')
and not api_utils.is_valid_logical_name(portgroup['name'])):
error_msg = _("Cannot create portgroup with invalid name "
"'%(name)s'") % {
'name': portgroup['name']
}
raise exception.ClientSideError(
error_msg, status_code=http_client.BAD_REQUEST)
# NOTE(yuriyz): UUID is mandatory for notifications payload
if not portgroup.get('uuid'):
portgroup['uuid'] = uuidutils.generate_uuid()
new_portgroup = objects.Portgroup(context, **portgroup)
notify.emit_start_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid)
with notify.handle_error_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid):
new_portgroup.create()
notify.emit_end_notification(context,
new_portgroup,
'create',
node_uuid=node.uuid)
# Set the HTTP Location Header
api.response.location = link.build_url('portgroups',
new_portgroup.uuid)
return convert_with_links(new_portgroup)
def post(self, port):
"""Create a new port.
:param port: a port within the request body.
:raises: NotAcceptable, HTTPNotFound, Conflict
"""
if self.parent_node_ident or self.parent_portgroup_ident:
raise exception.OperationNotPermitted()
context = api.request.context
api_utils.check_policy('baremetal:port:create')
# NOTE(lucasagomes): Create the node_id attribute on-the-fly
# to satisfy the api -> rpc object
# conversion.
node = api_utils.replace_node_uuid_with_id(port)
self._check_allowed_port_fields(port)
portgroup = None
if port.get('portgroup_uuid'):
try:
portgroup = objects.Portgroup.get(api.request.context,
port.pop('portgroup_uuid'))
if portgroup.node_id != node.id:
raise exception.BadRequest(_('Port can not be added to a '
'portgroup belonging to a '
'different node.'))
# NOTE(lucasagomes): Create the portgroup_id attribute
# on-the-fly to satisfy the api ->
# rpc object conversion.
port['portgroup_id'] = portgroup.id
except exception.PortgroupNotFound as e:
# Change error code because 404 (NotFound) is inappropriate
# response for a POST request to create a Port
e.code = http_client.BAD_REQUEST # BadRequest
raise e
if port.get('is_smartnic'):
try:
api_utils.LOCAL_LINK_SMART_NIC_VALIDATOR(
'local_link_connection',
port.get('local_link_connection'))
except exception.Invalid:
raise exception.Invalid(
"Smart NIC port must have port_id "
"and hostname in local_link_connection")
physical_network = port.get('physical_network')
if physical_network is not None and not physical_network:
raise exception.Invalid('A non-empty value is required when '
'setting physical_network')
vif = api_utils.handle_post_port_like_extra_vif(port)
if (portgroup and (port.get('pxe_enabled') or vif)):
if not portgroup.standalone_ports_supported:
msg = _("Port group %s doesn't support standalone ports. "
"This port cannot be created as a member of that "
"port group because either 'extra/vif_port_id' "
"was specified or 'pxe_enabled' was set to True.")
raise exception.Conflict(
msg % portgroup.uuid)
# NOTE(yuriyz): UUID is mandatory for notifications payload
if not port.get('uuid'):
port['uuid'] = uuidutils.generate_uuid()
rpc_port = objects.Port(context, **port)
notify_extra = {
'node_uuid': node.uuid,
'portgroup_uuid': portgroup and portgroup.uuid or None
}
notify.emit_start_notification(context, rpc_port, 'create',
**notify_extra)
with notify.handle_error_notification(context, rpc_port, 'create',
**notify_extra):
topic = api.request.rpcapi.get_topic_for(node)
new_port = api.request.rpcapi.create_port(context, rpc_port,
topic)
notify.emit_end_notification(context, new_port, 'create',
**notify_extra)
# Set the HTTP Location Header
api.response.location = link.build_url('ports', new_port.uuid)
return convert_with_links(new_port)
def post(self, port):
"""Create a new port.
:param port: a port within the request body.
:raises: NotAcceptable, HTTPNotFound, Conflict
"""
if self.parent_node_ident or self.parent_portgroup_ident:
raise exception.OperationNotPermitted()
# NOTE(lucasagomes): Create the node_id attribute on-the-fly
# to satisfy the api -> rpc object
# conversion.
# NOTE(TheJulia): The get of the node *does* check if the node
# can be accessed. We need to be able to get the node regardless
# in order to perform the actual policy check.
raise_node_not_found = False
node = None
owner = None
lessee = None
node_uuid = port.get('node_uuid')
try:
node = api_utils.replace_node_uuid_with_id(port)
owner = node.owner
lessee = node.lessee
except exception.NotFound:
raise_node_not_found = True
# While the rule is for the port, the base object that controls access
# is the node.
api_utils.check_owner_policy('node',
'baremetal:port:create',
owner,
lessee=lessee,
conceal_node=False)
if raise_node_not_found:
# Delayed raise of NodeNotFound because we want to check
# the access policy first.
raise exception.NodeNotFound(node=node_uuid,
code=http_client.BAD_REQUEST)
context = api.request.context
self._check_allowed_port_fields(port)
portgroup = None
if port.get('portgroup_uuid'):
try:
portgroup = objects.Portgroup.get(api.request.context,
port.pop('portgroup_uuid'))
if portgroup.node_id != node.id:
raise exception.BadRequest(
_('Port can not be added to a '
'portgroup belonging to a '
'different node.'))
# NOTE(lucasagomes): Create the portgroup_id attribute
# on-the-fly to satisfy the api ->
# rpc object conversion.
port['portgroup_id'] = portgroup.id
except exception.PortgroupNotFound as e:
# Change error code because 404 (NotFound) is inappropriate
# response for a POST request to create a Port
e.code = http_client.BAD_REQUEST # BadRequest
raise e
if port.get('is_smartnic'):
try:
api_utils.LOCAL_LINK_SMART_NIC_VALIDATOR(
'local_link_connection', port.get('local_link_connection'))
except exception.Invalid:
raise exception.Invalid(
"Smart NIC port must have port_id "
"and hostname in local_link_connection")
physical_network = port.get('physical_network')
if physical_network is not None and not physical_network:
raise exception.Invalid('A non-empty value is required when '
'setting physical_network')
if (portgroup and (port.get('pxe_enabled'))):
if not portgroup.standalone_ports_supported:
msg = _("Port group %s doesn't support standalone ports. "
"This port cannot be created as a member of that "
"portgroup as the port's 'pxe_enabled' field was "
"set to True.")
raise exception.Conflict(msg % portgroup.uuid)
# NOTE(yuriyz): UUID is mandatory for notifications payload
if not port.get('uuid'):
port['uuid'] = uuidutils.generate_uuid()
rpc_port = objects.Port(context, **port)
notify_extra = {
'node_uuid': node.uuid,
'portgroup_uuid': portgroup and portgroup.uuid or None
}
notify.emit_start_notification(context, rpc_port, 'create',
**notify_extra)
with notify.handle_error_notification(context, rpc_port, 'create',
**notify_extra):
topic = api.request.rpcapi.get_topic_for(node)
new_port = api.request.rpcapi.create_port(context, rpc_port, topic)
notify.emit_end_notification(context, new_port, 'create',
**notify_extra)
# Set the HTTP Location Header
api.response.location = link.build_url('ports', new_port.uuid)
return convert_with_links(new_port)
