from snaps import file_utils
from snaps.config.flavor import FlavorConfig
from snaps.config.keypair import KeypairConfig
+from snaps.config.network import SubnetConfig, PortConfig, NetworkConfig
from snaps.config.router import RouterConfig
+from snaps.config.security_group import (
+ SecurityGroupRuleConfig, SecurityGroupConfig)
+from snaps.config.vm_inst import VmInstanceConfig, FloatingIpConfig
from snaps.config.volume import VolumeConfig
from snaps.config.volume_type import (
ControlLocation, VolumeTypeEncryptionConfig, VolumeTypeConfig)
-from snaps.openstack.create_instance import (
- VmInstanceSettings, FloatingIpSettings)
-from snaps.openstack.create_network import (
- PortSettings, SubnetSettings, NetworkSettings)
-from snaps.openstack.create_security_group import (
- SecurityGroupSettings, SecurityGroupRuleSettings)
from snaps.openstack.utils import (
neutron_utils, nova_utils, heat_utils, glance_utils)
-def create_network_settings(neutron, network):
+def create_network_config(neutron, network):
"""
- Returns a NetworkSettings object
+ Returns a NetworkConfig object
:param neutron: the neutron client
:param network: a SNAPS-OO Network domain object
:return:
"""
- return NetworkSettings(
+ return NetworkConfig(
name=network.name, network_type=network.type,
- subnet_settings=create_subnet_settings(neutron, network))
+ subnet_settings=create_subnet_config(neutron, network))
-def create_security_group_settings(neutron, security_group):
+def create_security_group_config(neutron, security_group):
"""
- Returns a NetworkSettings object
+ Returns a SecurityGroupConfig object
:param neutron: the neutron client
:param security_group: a SNAPS-OO SecurityGroup domain object
:return:
rule_settings = list()
for rule in rules:
- rule_settings.append(SecurityGroupRuleSettings(
+ rule_settings.append(SecurityGroupRuleConfig(
sec_grp_name=security_group.name, description=rule.description,
direction=rule.direction, ethertype=rule.ethertype,
port_range_min=rule.port_range_min,
remote_group_id=rule.remote_group_id,
remote_ip_prefix=rule.remote_ip_prefix))
- return SecurityGroupSettings(
+ return SecurityGroupConfig(
name=security_group.name, description=security_group.description,
rule_settings=rule_settings)
-def create_subnet_settings(neutron, network):
+def create_subnet_config(neutron, network):
"""
- Returns a list of SubnetSettings objects for a given network
+ Returns a list of SubnetConfig objects for a given network
:param neutron: the OpenStack neutron client
:param network: the SNAPS-OO Network domain object
:return: a list
kwargs['host_routes'] = subnet.host_routes
kwargs['ipv6_ra_mode'] = subnet.ipv6_ra_mode
kwargs['ipv6_address_mode'] = subnet.ipv6_address_mode
- out.append(SubnetSettings(**kwargs))
+ out.append(SubnetConfig(**kwargs))
return out
-def create_router_settings(neutron, router):
+def create_router_config(neutron, router):
"""
Returns a RouterConfig object
:param neutron: the neutron client
if network:
ext_net_name = network.name
- ports_tuple_list = list()
+ out_ports = list()
if router.port_subnets:
for port, subnets in router.port_subnets:
network = neutron_utils.get_network_by_id(
ip_addrs.append(ext_fixed_ips['ip_address'])
else:
for ip in port.ips:
- ip_addrs.append(ip)
+ ip_addrs.append(ip['ip_address'])
- ip_list = list()
- if len(ip_addrs) > 0:
- for ip_addr in ip_addrs:
- if isinstance(ip_addr, dict):
- ip_list.append(ip_addr['ip_address'])
- else:
- ip_list.append(ip_addr)
+ ports = neutron_utils.get_ports(neutron, network, ip_addrs)
+ for out_port in ports:
+ out_ports.append(out_port)
- ports_tuple_list.append((network, ip_list))
-
- port_settings = __create_port_settings(neutron, ports_tuple_list)
+ port_settings = __create_port_configs(neutron, out_ports)
filtered_settings = list()
for port_setting in port_settings:
def create_volume_config(volume):
"""
- Returns a VolumeSettings object
+ Returns a VolumeConfig object
:param volume: a SNAPS-OO Volume object
"""
def create_volume_type_config(volume_type):
"""
- Returns a VolumeTypeSettings object
+ Returns a VolumeTypeConfig object
:param volume_type: a SNAPS-OO VolumeType object
"""
else:
control = ControlLocation.back_end
- encrypt_settings = VolumeTypeEncryptionConfig(
- name=volume_type.encryption.__class__,
- provider_class=volume_type.encryption.provider,
- control_location=control,
- cipher=volume_type.encryption.cipher,
- key_size=volume_type.encryption.key_size)
+ if volume_type and volume_type.encryption:
+ encrypt_settings = VolumeTypeEncryptionConfig(
+ name=volume_type.encryption.__class__,
+ provider_class=volume_type.encryption.provider,
+ control_location=control,
+ cipher=volume_type.encryption.cipher,
+ key_size=volume_type.encryption.key_size)
+ else:
+ encrypt_settings = None
qos_spec_name = None
if volume_type.qos_spec:
def create_flavor_config(flavor):
"""
- Returns a VolumeSettings object
- :param flavor: a SNAPS-OO Volume object
+ Returns a FlavorConfig object
+ :param flavor: a FlavorConfig object
"""
return FlavorConfig(
name=flavor.name, flavor_id=flavor.id, ram=flavor.ram,
is_public=flavor.is_public)
-def create_keypair_settings(heat_cli, stack, keypair, pk_output_key):
+def create_keypair_config(heat_cli, stack, keypair, pk_output_key):
"""
Instantiates a KeypairConfig object from a Keypair domain objects
:param heat_cli: the heat client
return KeypairConfig(name=keypair.name)
-def create_vm_inst_settings(nova, neutron, server):
+def create_vm_inst_config(nova, keystone, neutron, server, project_name):
"""
- Returns a NetworkSettings object
+ Returns a VmInstanceConfig object
+ note: if the server instance is not active, the PortSettings objects will
+ not be generated resulting in an invalid configuration
:param nova: the nova client
+ :param keystone: the keystone client
:param neutron: the neutron client
:param server: a SNAPS-OO VmInst domain object
+ :param project_name: the associated project name
:return:
"""
kwargs['name'] = server.name
kwargs['flavor'] = flavor_name
- net_tuples = list()
- for net_name, ips in server.networks.items():
- network = neutron_utils.get_network(neutron, network_name=net_name)
- if network:
- net_tuples.append((network, ips))
-
- kwargs['port_settings'] = __create_port_settings(
- neutron, net_tuples)
+ kwargs['port_settings'] = __create_port_configs(neutron, server.ports)
kwargs['security_group_names'] = server.sec_grp_names
- kwargs['floating_ip_settings'] = __create_floatingip_settings(
- neutron, kwargs['port_settings'])
+ kwargs['floating_ip_settings'] = __create_floatingip_config(
+ neutron, keystone, kwargs['port_settings'], project_name)
- return VmInstanceSettings(**kwargs)
+ return VmInstanceConfig(**kwargs)
-def __create_port_settings(neutron, networks):
+def __create_port_configs(neutron, ports):
"""
- Returns a list of port settings based on the networks parameter
+ Returns a list of PortConfig objects based on the networks parameter
:param neutron: the neutron client
- :param networks: a list of tuples where #1 is the SNAPS Network domain
- object and #2 is a list of IP addresses
+ :param ports: a list of SNAPS-OO Port domain objects
:return:
"""
out = list()
- for network, ips in networks:
- ports = neutron_utils.get_ports(neutron, network, ips)
- for port in ports:
- if port.device_owner != 'network:dhcp':
- ip_addrs = list()
- for ip_dict in port.ips:
- subnet = neutron_utils.get_subnet_by_id(
- neutron, ip_dict['subnet_id'])
- ip_addrs.append({'subnet_name': subnet.name,
- 'ip': ip_dict['ip_address']})
-
- kwargs = dict()
- if port.name:
- kwargs['name'] = port.name
- kwargs['network_name'] = network.name
- kwargs['mac_address'] = port.mac_address
- kwargs['allowed_address_pairs'] = port.allowed_address_pairs
- kwargs['admin_state_up'] = port.admin_state_up
- kwargs['ip_addrs'] = ip_addrs
- out.append(PortSettings(**kwargs))
+ for port in ports:
+ if port.device_owner != 'network:dhcp':
+ ip_addrs = list()
+ for ip_dict in port.ips:
+ subnet = neutron_utils.get_subnet_by_id(
+ neutron, ip_dict['subnet_id'])
+ ip_addrs.append({'subnet_name': subnet.name,
+ 'ip': ip_dict['ip_address']})
+
+ network = neutron_utils.get_network_by_id(neutron, port.network_id)
+ kwargs = dict()
+ if port.name:
+ kwargs['name'] = port.name
+ kwargs['network_name'] = network.name
+ kwargs['mac_address'] = port.mac_address
+ kwargs['allowed_address_pairs'] = port.allowed_address_pairs
+ kwargs['admin_state_up'] = port.admin_state_up
+ kwargs['ip_addrs'] = ip_addrs
+ out.append(PortConfig(**kwargs))
return out
-def __create_floatingip_settings(neutron, port_settings):
+def __create_floatingip_config(neutron, keystone, port_settings, project_name):
"""
- Returns a list of FloatingIPSettings objects as they pertain to an
+ Returns a list of FloatingIpConfig objects as they pertain to an
existing deployed server instance
:param neutron: the neutron client
- :param port_settings: list of SNAPS-OO PortSettings objects
- :return: a list of FloatingIPSettings objects or an empty list if no
+ :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_ports = list()
for port_setting in port_settings:
- setting_port = neutron_utils.get_port(neutron, port_setting)
+ setting_port = neutron_utils.get_port(
+ neutron, keystone, port_setting, project_name=project_name)
if setting_port:
network = neutron_utils.get_network(
- neutron, network_name=port_setting.network_name)
+ 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:
fip_ports.append((port_setting.name, setting_port))
break
- floating_ips = neutron_utils.get_floating_ips(neutron, fip_ports)
+ 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)
if subnet:
kwargs['subnet_name'] = subnet.name
- out.append(FloatingIpSettings(**kwargs))
+ out.append(FloatingIpConfig(**kwargs))
fip_ctr += 1
Code Review / snaps.git / blobdiff