def _retrieve_machine(provider_id, machine_uuid, skip_store):
"""Return a machine object from an id.
"""
machine = Machine.fetch(machine_uuid)
if not machine and not skip_store:
raise _errors.MachineError("Machine (%s) does not exist." %
(machine_uuid, ))
if machine and machine.provider_id != provider_id:
raise _errors.MachineError(
"Machine (%s) does not belong to provider (%s)." %
(machine_uuid, provider_id))
return machine
def _kv_to_dict(meta):
"""Transform a list with key/value strings into a dictionary.
"""
try:
return dict(m.split("=", 1) for m in meta)
except ValueError:
raise _errors.MachineError("Invalid parameter (%s)." % (meta, ))
def _find_private_nics(cs, ns, net_parameters):
"""Find out information on private networks.
"""
nics = []
try:
for net in net_parameters:
nic = cs.networks.find(label=net)
nics.append({'net-id' : nic.id})
return nics
except novaclient.exceptions.NotFound:
# Most likely this means that neutron is being used. So before
# aborting the operation, we will try to use the neutron client
# to find out the nic-id.
pass
try:
for net in net_parameters:
networks = ns.list_networks(retrieve_all=False, name=net)
for network in networks:
net_id = network['networks'][0]['id']
nics.append({'net-id' : net_id})
return nics
except IndexError:
# Nothing was found and the attempt to retrieve information
# at network['networks'][0]['id'] causes an exception.
pass
raise _errors.MachineError(
"Private network (%s) not found." % (net_parameters, )
)
def wrapper_catch_exception(*args, **kwargs):
"""Wrapper to catch OpenStack exceptions.
"""
try:
return function(*args, **kwargs)
except (UnsupportedVersion, CommandError, AuthorizationFailure,
NoUniqueMatch, AuthSystemNotFound, NoTokenLookupException,
EndpointNotFound, AmbiguousEndpoints, ConnectionRefused,
ClientException) as error:
raise _errors.MachineError(error)
def keep_waiting(obj, get_info, status):
"""Keep pooling until the status changes.
Note that this function does not fetch detailed information when there
is an error and this needs to be improved.
"""
while obj.status in status:
time.sleep(5)
obj = get_info(obj.id)
if obj.status != 'ACTIVE':
raise _errors.MachineError(
"Unexpected status (%s) when valid statuses were (%s). "
"Error creating resource (%)." % (obj.status, status, str(obj.id))
)
def _create_floating_ip(cs, ns, pool):
try:
return cs.floating_ips.create(pool=pool)
return floating_ip
except novaclient.exceptions.NotFound:
# Most likely this means that neutron or a proprietary API is being
# used. So before aborting the operation, we will try to use the
# neutron client to create a floating ip.
pass
raise _errors.MachineError(
"Error accessing public network (%s)." % (pool, )
)
def preprocess_meta(meta):
"""Preprocess parameters that will be used to search for resources in
the cloud.
This is necessary because the parameters are strings and some of them
need to be converted to integers or floats. Besides the parameter names
are case sensitive and must be changed.
"""
proc_meta = {}
for key, value in meta.iteritems():
key = key.lower()
if key in SEARCH_PROPERTIES:
key, convert = SEARCH_PROPERTIES[key]
try:
value = convert(value)
except ValueError as error:
raise _errors.MachineError(error)
proc_meta[key] = value
return proc_meta
def _preprocess_paramaters(parameters, machine_group_uuid, provider):
"""Process paramaters.
"""
# 1. Put image parameter in the appropriate format.
if parameters['image']:
parameters['image'] = _kv_to_dict(parameters['image'])
elif provider.default_image:
parameters['image'] = {'name': provider.default_image}
if not parameters['image']:
raise _errors.MachineError("No valid image hasn't been found.")
# 2. Put flavor parameter in the appropriate format.
if parameters['flavor']:
parameters['flavor'] = _kv_to_dict(parameters['flavor'])
elif provider.default_flavor:
parameters['flavor'] = {'name': provider.default_flavor}
if not parameters['flavor']:
raise _errors.MachineError("No valid flavor hasn't been found.")
# 3. Check the parameter number_machines.
number_machines = parameters['number_machines']
try:
number_machines = int(number_machines)
parameters['number_machines'] = number_machines
except TypeError:
number_machines = 1
parameters['number_machines'] = number_machines
if number_machines <= 0:
raise _errors.MachineError(
"Number of machines must be greater than zero (%s)." %
(number_machines, ))
# 4. We don't need to check the availability_zone parameter
# 5. We don't need to check the parameter key_name parameter.
# 6. Put the security_groups parameter in the appropriate format.
if parameters['security_groups']:
security_groups = parameters['security_groups'].split(',')
parameters['security_groups'] = security_groups
# 7. Check the private_newtwork parameter.
private_nics = parameters['private_nics']
private_network = parameters['private_network']
if private_network and private_nics:
raise _errors.ConfigurationError(
"Can't define both private_network (%s) and private_nics "
"parameters (%s)." % (private_network, private_nics))
# 8. Check the public_newtwork parameter.
public_nics = parameters['public_nics']
public_network = parameters['public_network']
if public_network and public_nics:
raise _errors.ConfigurationError(
"Can't define both public_network (%s) and public_nics "
"parameters (%s)." % (public_network, public_nics))
# 9. Read userdata parameter which must be a path to a file.
if parameters['userdata']:
try:
src = parameters['userdata']
userdata = open(src)
except IOError as error:
raise _errors.ConfigurationError("Can't open '%(src)s': %(exc)s" %
{
'src': src,
'exc': error
})
parameters['userdata'] = userdata
# 10. We don't need to check the swap parameter
# 11. Put the block_device parameter in the appropriate format.
if parameters['block_device']:
raise _errors.ConfigurationError(
"Parameter block_device is not supported yet.")
# 12. Put the scheduler_hints parameter in the appropriate format.
if parameters['scheduler_hints']:
parameters['scheduler_hints'] = \
_kv_to_dict(parameters['scheduler_hints'])
# 13. Put the private_nics parameter in the appropriate format.
if parameters['private_nics']:
raise _errors.ConfigurationError(
"Parameter private_nics is not supported yet.")
# 14. Put the public_nics parameter in the appropriate format.
if parameters['public_nics']:
raise _errors.ConfigurationError(
"Parameter public_nics is not supported yet.")
# 15. Put meta parameter in the appropriate format.
reserved_value = ('True',
str(FabricNode().version), str(FabricNode().uuid),
str(FabricNode().group_uuid), machine_group_uuid)
assert len(reserved_meta) == len(reserved_value)
if parameters['meta']:
parameters['meta'] = _kv_to_dict(parameters['meta'])
if any([key in reserved_meta
for key in parameters['meta'].iterkeys()]):
raise _errors.ConfigurationError(
"The meta parameter cannot have key words in the following "
"list: %s. They are reserved for internal use." %
(str(reserved_meta), ))
else:
parameters['meta'] = {}
meta = dict(zip(reserved_meta, reserved_value))
parameters['meta'].update(meta)
