python-ironicclient/ironicclient/v1/create_resources.py
Riccardo Pittau a572ae21e7 Stop using six library
Since we've dropped support for Python 2.7, it's time to look at
the bright future that Python 3.x will bring and stop forcing
compatibility with older versions.
This patch removes the six library from requirements, not
looking back.

Change-Id: I4b60638bb0268e5d1cf54fdf7d61964082536f4f
2019-12-18 15:18:24 +01:00

343 lines
13 KiB
Python

# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import functools
import json
import jsonschema
import yaml
from ironicclient import exc
_CREATE_SCHEMA = {
"$schema": "http://json-schema.org/draft-04/schema#",
"description": "Schema for ironic resources file",
"type": "object",
"properties": {
"chassis": {
"type": "array",
"items": {
"type": "object"
}
},
"nodes": {
"type": "array",
"items": {
"type": "object"
}
}
},
"additionalProperties": False
}
def create_resources(client, filenames):
"""Create resources using their JSON or YAML descriptions.
:param client: an instance of ironic client;
:param filenames: a list of filenames containing JSON or YAML resources
definitions.
:raises: ClientException if any operation during files processing/resource
creation fails.
"""
errors = []
resources = []
for resource_file in filenames:
try:
resource = load_from_file(resource_file)
jsonschema.validate(resource, _CREATE_SCHEMA)
resources.append(resource)
except (exc.ClientException, jsonschema.ValidationError) as e:
errors.append(e)
if errors:
raise exc.ClientException('While validating the resources file(s), the'
' following error(s) were encountered:\n%s' %
'\n'.join(str(e) for e in errors))
for r in resources:
errors.extend(create_chassis(client, r.get('chassis', [])))
errors.extend(create_nodes(client, r.get('nodes', [])))
if errors:
raise exc.ClientException('During resources creation, the following '
'error(s) were encountered:\n%s' %
'\n'.join(str(e) for e in errors))
def load_from_file(filename):
"""Deserialize JSON or YAML from file.
:param filename: name of the file containing JSON or YAML.
:returns: a dictionary deserialized from JSON or YAML.
:raises: ClientException if the file can not be loaded or if its contents
is not a valid JSON or YAML, or if the file extension is not supported.
"""
try:
with open(filename) as f:
if filename.endswith('.yaml'):
return yaml.safe_load(f)
elif filename.endswith('.json'):
return json.load(f)
else:
# The file is neither .json, nor .yaml, raise an exception
raise exc.ClientException(
'Cannot process file "%(file)s" - it must have .json or '
'.yaml extension.' % {'file': filename})
except IOError as e:
raise exc.ClientException('Cannot read file "%(file)s" due to '
'error: %(err)s' %
{'err': e, 'file': filename})
except (ValueError, yaml.YAMLError) as e:
# json.load raises only ValueError
raise exc.ClientException('File "%(file)s" is invalid due to error: '
'%(err)s' % {'err': e, 'file': filename})
def create_single_handler(resource_type):
"""Catch errors of the creation of a single resource.
This decorator appends an error (which is an instance of some client
exception class) to the return value of the create_method, changing the
return value from just UUID to (UUID, error), and does some exception
handling.
:param resource_type: string value, the type of the resource being created,
e.g. 'node', used purely for exception messages.
"""
def outer_wrapper(create_method):
@functools.wraps(create_method)
def wrapper(client, **params):
uuid = None
error = None
try:
uuid = create_method(client, **params)
except exc.InvalidAttribute as e:
error = exc.InvalidAttribute(
'Cannot create the %(resource)s with attributes '
'%(params)s. One or more attributes are invalid: %(err)s' %
{'params': params, 'resource': resource_type, 'err': e}
)
except Exception as e:
error = exc.ClientException(
'Unable to create the %(resource)s with the specified '
'attributes: %(params)s. The error is: %(error)s' %
{'error': e, 'resource': resource_type, 'params': params})
return uuid, error
return wrapper
return outer_wrapper
@create_single_handler('node')
def create_single_node(client, **params):
"""Call the client to create a node.
:param client: ironic client instance.
:param params: dictionary to be POSTed to /nodes endpoint, excluding
"ports" and "portgroups" keys.
:returns: UUID of the created node or None in case of exception, and an
exception, if it appears.
:raises: InvalidAttribute, if some parameters passed to client's
create_method are invalid.
:raises: ClientException, if the creation of the node fails.
"""
params.pop('ports', None)
params.pop('portgroups', None)
ret = client.node.create(**params)
return ret.uuid
@create_single_handler('port')
def create_single_port(client, **params):
"""Call the client to create a port.
:param client: ironic client instance.
:param params: dictionary to be POSTed to /ports endpoint.
:returns: UUID of the created port or None in case of exception, and an
exception, if it appears.
:raises: InvalidAttribute, if some parameters passed to client's
create_method are invalid.
:raises: ClientException, if the creation of the port fails.
"""
ret = client.port.create(**params)
return ret.uuid
@create_single_handler('port group')
def create_single_portgroup(client, **params):
"""Call the client to create a port group.
:param client: ironic client instance.
:param params: dictionary to be POSTed to /portgroups endpoint, excluding
"ports" key.
:returns: UUID of the created port group or None in case of exception, and
an exception, if it appears.
:raises: InvalidAttribute, if some parameters passed to client's
create_method are invalid.
:raises: ClientException, if the creation of the portgroup fails.
"""
params.pop('ports', None)
ret = client.portgroup.create(**params)
return ret.uuid
@create_single_handler('chassis')
def create_single_chassis(client, **params):
"""Call the client to create a chassis.
:param client: ironic client instance.
:param params: dictionary to be POSTed to /chassis endpoint, excluding
"nodes" key.
:returns: UUID of the created chassis or None in case of exception, and an
exception, if it appears.
:raises: InvalidAttribute, if some parameters passed to client's
create_method are invalid.
:raises: ClientException, if the creation of the chassis fails.
"""
params.pop('nodes', None)
ret = client.chassis.create(**params)
return ret.uuid
def create_ports(client, port_list, node_uuid, portgroup_uuid=None):
"""Create ports from dictionaries.
:param client: ironic client instance.
:param port_list: list of dictionaries to be POSTed to /ports
endpoint.
:param node_uuid: UUID of a node the ports should be associated with.
:param portgroup_uuid: UUID of a port group the ports should be associated
with, if they are its members.
:returns: array of exceptions encountered during creation.
"""
errors = []
for port in port_list:
port_node_uuid = port.get('node_uuid')
if port_node_uuid and port_node_uuid != node_uuid:
errors.append(exc.ClientException(
'Cannot create a port as part of node %(node_uuid)s '
'because the port %(port)s has a different node UUID '
'specified.',
{'node_uuid': node_uuid,
'port': port}))
continue
port['node_uuid'] = node_uuid
if portgroup_uuid:
port_portgroup_uuid = port.get('portgroup_uuid')
if port_portgroup_uuid and port_portgroup_uuid != portgroup_uuid:
errors.append(exc.ClientException(
'Cannot create a port as part of port group '
'%(portgroup_uuid)s because the port %(port)s has a '
'different port group UUID specified.',
{'portgroup_uuid': portgroup_uuid,
'port': port}))
continue
port['portgroup_uuid'] = portgroup_uuid
port_uuid, error = create_single_port(client, **port)
if error:
errors.append(error)
return errors
def create_portgroups(client, portgroup_list, node_uuid):
"""Create port groups from dictionaries.
:param client: ironic client instance.
:param portgroup_list: list of dictionaries to be POSTed to /portgroups
endpoint, if some of them contain "ports" key, its content is POSTed
separately to /ports endpoint.
:param node_uuid: UUID of a node the port groups should be associated with.
:returns: array of exceptions encountered during creation.
"""
errors = []
for portgroup in portgroup_list:
portgroup_node_uuid = portgroup.get('node_uuid')
if portgroup_node_uuid and portgroup_node_uuid != node_uuid:
errors.append(exc.ClientException(
'Cannot create a port group as part of node %(node_uuid)s '
'because the port group %(portgroup)s has a different node '
'UUID specified.',
{'node_uuid': node_uuid,
'portgroup': portgroup}))
continue
portgroup['node_uuid'] = node_uuid
portgroup_uuid, error = create_single_portgroup(client, **portgroup)
if error:
errors.append(error)
ports = portgroup.get('ports')
# Port group UUID == None means that port group creation failed, don't
# create the ports inside it
if ports is not None and portgroup_uuid is not None:
errors.extend(create_ports(client, ports, node_uuid,
portgroup_uuid=portgroup_uuid))
return errors
def create_nodes(client, node_list, chassis_uuid=None):
"""Create nodes from dictionaries.
:param client: ironic client instance.
:param node_list: list of dictionaries to be POSTed to /nodes
endpoint, if some of them contain "ports" key, its content is POSTed
separately to /ports endpoint.
:param chassis_uuid: UUID of a chassis the nodes should be associated with.
:returns: array of exceptions encountered during creation.
"""
errors = []
for node in node_list:
if chassis_uuid is not None:
node_chassis_uuid = node.get('chassis_uuid')
if node_chassis_uuid and node_chassis_uuid != chassis_uuid:
errors.append(exc.ClientException(
'Cannot create a node as part of chassis %(chassis_uuid)s '
'because the node %(node)s has a different chassis UUID '
'specified.' %
{'chassis_uuid': chassis_uuid,
'node': node}))
continue
node['chassis_uuid'] = chassis_uuid
node_uuid, error = create_single_node(client, **node)
if error:
errors.append(error)
ports = node.get('ports')
portgroups = node.get('portgroups')
# Node UUID == None means that node creation failed, don't
# create the port(group)s inside it
if node_uuid is not None:
if portgroups is not None:
errors.extend(
create_portgroups(client, portgroups, node_uuid))
if ports is not None:
errors.extend(create_ports(client, ports, node_uuid))
return errors
def create_chassis(client, chassis_list):
"""Create chassis from dictionaries.
:param client: ironic client instance.
:param chassis_list: list of dictionaries to be POSTed to /chassis
endpoint, if some of them contain "nodes" key, its content is POSTed
separately to /nodes endpoint.
:returns: array of exceptions encountered during creation.
"""
errors = []
for chassis in chassis_list:
chassis_uuid, error = create_single_chassis(client, **chassis)
if error:
errors.append(error)
nodes = chassis.get('nodes')
# Chassis UUID == None means that chassis creation failed, don't
# create the nodes inside it
if nodes is not None and chassis_uuid is not None:
errors.extend(create_nodes(client, nodes,
chassis_uuid=chassis_uuid))
return errors