def create(self):
"""
Responsible for creating the router.
:return: the Router domain object
"""
self.initialize()
if not self.__router:
self.__router = neutron_utils.create_router(
self._neutron, self._os_creds, self.router_settings)
for sub_config in self.router_settings.internal_subnets:
internal_subnet = self.__get_internal_subnet(sub_config)
if internal_subnet:
self.__internal_subnets.append(internal_subnet)
if internal_subnet:
logger.debug('Adding router to subnet...')
router_intf = neutron_utils.add_interface_router(
self._neutron,
self.__router,
subnet=internal_subnet)
self.__internal_router_interface = router_intf
else:
raise RouterCreationError(
'Subnet not found with name {}'.format(sub_config))
for port_setting in self.router_settings.port_settings:
port = neutron_utils.get_port(
self._neutron,
self._keystone,
port_settings=port_setting,
project_name=self._os_creds.project_name)
logger.info('Retrieved port %s for router - %s',
port_setting.name, self.router_settings.name)
if port:
self.__ports.append(port)
if not port:
port = neutron_utils.create_port(self._neutron,
self._os_creds,
port_setting)
if port:
logger.info('Created port %s for router - %s',
port_setting.name,
self.router_settings.name)
self.__ports.append(port)
neutron_utils.add_interface_router(self._neutron,
self.__router,
port=port)
else:
raise RouterCreationError(
'Error creating port with name - ' +
port_setting.name)
self.__router = neutron_utils.get_router_by_id(self._neutron,
self.__router.id)
return self.__router
def __create_floatingip_config(neutron, keystone, port_settings, project_name):
"""
Returns a list of FloatingIpConfig objects as they pertain to an
existing deployed server instance
:param neutron: the neutron client
:param keystone: the keystone client
:param port_settings: list of SNAPS-OO PortConfig objects
:return: a list of FloatingIpConfig objects or an empty list if no
floating IPs have been created
"""
base_fip_name = 'fip-'
fip_ctr = 1
out = list()
fip_ports = list()
for port_setting in port_settings:
setting_port = neutron_utils.get_port(neutron,
keystone,
port_setting,
project_name=project_name)
if setting_port:
network = neutron_utils.get_network(
neutron, keystone, network_name=port_setting.network_name)
network_ports = neutron_utils.get_ports(neutron, network)
if network_ports:
for setting_port in network_ports:
if port_setting.mac_address == setting_port.mac_address:
fip_ports.append((port_setting.name, setting_port))
break
floating_ips = neutron_utils.get_port_floating_ips(neutron, fip_ports)
for port_id, floating_ip in floating_ips:
router = neutron_utils.get_router_by_id(neutron, floating_ip.router_id)
setting_port = neutron_utils.get_port_by_id(neutron,
floating_ip.port_id)
kwargs = dict()
kwargs['name'] = base_fip_name + str(fip_ctr)
kwargs['port_name'] = setting_port.name
kwargs['port_id'] = setting_port.id
kwargs['router_name'] = router.name
if setting_port:
for ip_dict in setting_port.ips:
if ('ip_address' in ip_dict and 'subnet_id' in ip_dict and
ip_dict['ip_address'] == floating_ip.fixed_ip_address):
subnet = neutron_utils.get_subnet_by_id(
neutron, ip_dict['subnet_id'])
if subnet:
kwargs['subnet_name'] = subnet.name
out.append(FloatingIpConfig(**kwargs))
fip_ctr += 1
return out
def __query_ports(self, port_settings):
"""
Returns the previously configured ports or an empty list if none
exist
:param port_settings: A list of PortSetting objects
:return: a list of OpenStack port tuples where the first member is the
port name and the second is the port object
"""
ports = list()
for port_setting in port_settings:
port = neutron_utils.get_port(
self.__neutron,
self.__keystone,
port_settings=port_setting,
project_name=self._os_creds.project_name)
if port:
ports.append((port_setting.name, port))
return ports
def initialize(self):
"""
Loads the existing router.
:return: the Router domain object
"""
super(self.__class__, self).initialize()
try:
self.__router = neutron_utils.get_router(
self._neutron,
self._keystone,
router_settings=self.router_settings,
project_name=self._os_creds.project_name)
except Unauthorized as e:
logger.warn('Unable to lookup router with name %s - %s',
self.router_settings.name, e)
if self.__router:
for sub_config in self.router_settings.internal_subnets:
internal_subnet = self.__get_internal_subnet(sub_config)
if internal_subnet:
self.__internal_subnets.append(internal_subnet)
else:
raise RouterCreationError('Subnet not found with name ' +
internal_subnet.name)
for port_setting in self.router_settings.port_settings:
port = neutron_utils.get_port(
self._neutron,
self._keystone,
port_settings=port_setting,
project_name=self._os_creds.project_name)
if port:
self.__ports.append(port)
return self.__router
def create_server(nova,
keystone,
neutron,
glance,
instance_config,
image_config,
project_name,
keypair_config=None):
"""
Creates a VM instance
:param nova: the nova client (required)
:param keystone: the keystone client for retrieving projects (required)
:param neutron: the neutron client for retrieving ports (required)
:param glance: the glance client (required)
:param instance_config: the VMInstConfig object (required)
:param image_config: the VM's ImageConfig object (required)
:param project_name: the associated project name (required)
:param keypair_config: the VM's KeypairConfig object (optional)
:return: a snaps.domain.VmInst object
"""
ports = list()
for port_setting in instance_config.port_settings:
port = neutron_utils.get_port(neutron,
keystone,
port_settings=port_setting,
project_name=project_name)
if port:
ports.append(port)
else:
raise Exception('Cannot find port named - ' + port_setting.name)
nics = []
for port in ports:
kv = dict()
kv['port-id'] = port.id
nics.append(kv)
logger.info('Creating VM with name - ' + instance_config.name)
keypair_name = None
if keypair_config:
keypair_name = keypair_config.name
flavor = get_flavor_by_name(nova, instance_config.flavor)
if not flavor:
raise NovaException('Flavor not found with name - %s',
instance_config.flavor)
image = glance_utils.get_image(glance, image_settings=image_config)
if image:
userdata = None
if instance_config.userdata:
if isinstance(instance_config.userdata, str):
userdata = instance_config.userdata + '\n'
elif (isinstance(instance_config.userdata, dict)
and 'script_file' in instance_config.userdata):
try:
userdata = file_utils.read_file(
instance_config.userdata['script_file'])
except Exception as e:
logger.warn('error reading userdata file %s - %s',
instance_config.userdata, e)
args = {
'name': instance_config.name,
'flavor': flavor,
'image': image,
'nics': nics,
'key_name': keypair_name,
'security_groups': instance_config.security_group_names,
'userdata': userdata
}
if instance_config.availability_zone:
args['availability_zone'] = instance_config.availability_zone
server = nova.servers.create(**args)
return __map_os_server_obj_to_vm_inst(neutron, keystone, server,
project_name)
else:
raise NovaException(
'Cannot create instance, image cannot be located with name %s',
image_config.name)