def _get_nova_flavor(self, name, vdu_data, vnf_data):
resource_type = 'OS::Nova::Flavor'
resource_prop = {
'flavorid': str(vnf_data['deploymentFlavour'][0]['flavourId']),
'name': str(name),
'is_public': False
}
# virtualMemory and virtualCpu properties
if 'virtualComputeDesc' in vdu_data and vdu_data[
'virtualComputeDesc'] is not None:
for vcd in vnf_data['virtualComputeDesc']:
if vcd['virtualComputeDescId'] == vdu_data[
'virtualComputeDesc']:
resource_prop['ram'] = int(
vcd['virtualMemory']['virtualMemSize'])
resource_prop['vcpus'] = int(
vcd['virtualCpu']['numVirtualCpu'])
# virtualStorageDesc
if 'virtualStorageDesc' in vdu_data and vdu_data[
'virtualStorageDesc'] is not None:
for vsd in vnf_data['virtualStorageDesc']:
if vsd['id'] == vdu_data['virtualStorageDesc']:
resource_prop['disk'] = str(vsd['sizeOfStorage'])
resource_prop['swap'] = 0
new_hot_resource = HotResource(name, resource_type, resource_prop)
return new_hot_resource
def _get_neutron_port(self, intcpd, vnf_data):
resource_type = 'OS::Neutron::Port'
resource_prop = {}
name = intcpd['cpdId']
network_name = intcpd['intVirtualLinkDesc']
extCpd = self._isIntCpd_conn_extCpd(intcpd, vnf_data)
if extCpd:
neutron_elem = self._translate_vnfExtCpd(extCpd, vnf_data)
else:
neutron_elem = self._get_neutron_net(network_name, vnf_data)
self.hot_template.add_resource(network_name, neutron_elem)
metadata_list = vnf_data['modifiableAttributes']['metadata']
for metadata in metadata_list:
if 'CPIPv4FixedIP' in metadata:
for index, fixed_ip in enumerate(metadata['CPIPv4FixedIP']):
if name in fixed_ip:
if 'fixed_ips' not in resource_prop:
resource_prop['fixed_ips'] = []
resource_prop['fixed_ips'].append(
{'ip_address': str(fixed_ip[name])})
# print "SUBNET for cpid:", name, network_name
subnet_name = 'subnet_' + name + '_' + str(index)
# neutron_subnet = self._get_resource_subnet(subnet_name, intcpd, vnf_data)
# self.hot_template.add_resource(subnet_name, neutron_subnet)
if 'properties' in metadata:
for prop in metadata['properties']:
if name in prop:
meta_prop = dict(pair for d in prop[name]
for pair in d.items())
resource_prop.update(meta_prop)
if 'addressData' in intcpd:
for addr in intcpd['addressData']:
if 'l2AddressData' in addr:
resource_prop['mac_address'] = str(addr['l2AddressData'])
if 'l3AddressData' in addr and addr['l3AddressData'][
'floatingIpActivated']:
if 'association' in addr['l3AddressData'] and addr[
'l3AddressData']['association']:
float_name = name + "_floating_ip_association"
neutron_floating_ip = self._get_floating_ip_association(
float_name, intcpd, vnf_data)
self.hot_template.add_resource(float_name,
neutron_floating_ip)
else:
float_name = name + "_floating_ip"
neutron_floating_ip = self._get_floating_ip(
float_name, intcpd, vnf_data)
self.hot_template.add_resource(float_name,
neutron_floating_ip)
if 'network' in resource_prop:
resource_prop['network']['get_resource'] = str(network_name)
else:
resource_prop['network'] = {'get_resource': str(network_name)}
new_hot_resource = HotResource(name, resource_type, resource_prop)
return new_hot_resource
def _get_neutron_provider_net(self, ext_cpd, vnf_data):
resource_type = 'OS::Neutron::ProviderNet'
resource_prop = {'name': str(ext_cpd['intVirtualLinkDesc'])}
meta_pro = self._get_properties_from_metadata(ext_cpd['cpdId'],
'properties', vnf_data)
resource_prop.update(meta_pro)
new_hot_resource = HotResource(ext_cpd['intVirtualLinkDesc'],
resource_type, resource_prop)
return new_hot_resource
def _translate_vdu(self, vdu_data, vnf_data):
log.debug('_translate_vdu id: %s', vdu_data['vduId'])
resource_type = self._infer_resource_type(vdu_data['vduId'], vnf_data)
log.debug('Resource type: %s', resource_type)
resource_properties = self._get_properties_vdu(resource_type, vdu_data,
vnf_data)
log.debug('Resource prop: %s', resource_properties)
new_hot_resource = HotResource(vdu_data['vduId'], resource_type,
resource_properties)
self.hot_template.add_resource(vdu_data['vduId'], new_hot_resource)
def _get_nova_key_pair(self, name, vdu_data, vnf_data):
resource_type = 'OS::Nova::KeyPair'
resource_prop = {'name': str(name)}
for prop in vdu_data['configurableProperties'][
'additionalVnfcConfigurableProperty']:
if 'SSHPubKey' in prop:
resource_prop['public_key'] = prop['SSHPubKey']
break
new_hot_resource = HotResource(name, resource_type, resource_prop)
return new_hot_resource
def _get_neutron_router_interface(self, router_id, intcpd, vnf_data):
resource_type = 'OS::Neutron::RouterInterface'
resource_prop = {'router': {'get_resource': str(router_id)}}
neutron_port_name = 'port_' + intcpd['cpdId']
neutron_port_res = self._get_neutron_port(intcpd, vnf_data)
self.hot_template.add_resource(neutron_port_name, neutron_port_res)
resource_prop['port'] = {'get_resource': str(neutron_port_name)}
new_hot_resource = HotResource('interf_' + router_id, resource_type,
resource_prop)
return new_hot_resource
def _get_subnet(self, subnet_name, prop, vnf_data):
resource_type = 'OS::Neutron::Subnet'
resource_prop = {
'name': subnet_name,
'network': {
'get_resource': str(prop['network'])
},
'cidr': str(prop['cidr'])
}
if 'dns_nameservers' in prop:
resource_prop['dns_nameservers'] = prop['dns_nameservers']
new_hot_resource = HotResource(subnet_name, resource_type,
resource_prop)
return new_hot_resource
def _get_floating_ip(self, float_name, intcpd, vnf_data):
resource_type = 'OS::Neutron::FloatingIP'
resource_prop = {
'port_id': {
'get_resource': 'port_' + str(intcpd['cpdId'])
}
}
meta_float_ip = self._get_properties_from_metadata(
intcpd['cpdId'], 'CPIPv4FloatingIP', vnf_data)
resource_prop.update(
{'floating_ip_address': str(meta_float_ip['CPIPv4FloatingIP'])})
meta_prop = self._get_properties_from_metadata(float_name,
'properties', vnf_data)
resource_prop.update(meta_prop)
new_hot_resource = HotResource(float_name, resource_type,
resource_prop)
return new_hot_resource
def _get_neutron_net(self, name, vnf_data):
resource_type = 'OS::Neutron::Net'
resource_prop = {'name': str(name)}
new_hot_resource = HotResource(name, resource_type, resource_prop)
return new_hot_resource