399 lines
16 KiB
Python
399 lines
16 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.
|
|
|
|
from oslo_config import cfg
|
|
from oslo_log import log as logging
|
|
from oslo_serialization import jsonutils
|
|
from oslo_utils import uuidutils
|
|
from toscaparser import tosca_template
|
|
from toscaparser.utils import yamlparser
|
|
from translator.hot import tosca_translator
|
|
import yaml
|
|
|
|
from tacker._i18n import _
|
|
from tacker.common import exceptions
|
|
from tacker.common import log
|
|
from tacker.extensions import common_services as cs
|
|
from tacker.extensions import vnfm
|
|
from tacker.plugins.common import constants
|
|
from tacker.tosca import utils as toscautils
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
CONF = cfg.CONF
|
|
|
|
OPTS = [
|
|
cfg.DictOpt('flavor_extra_specs',
|
|
default={},
|
|
help=_("Flavor Extra Specs")),
|
|
]
|
|
|
|
CONF.register_opts(OPTS, group='openstack_vim')
|
|
|
|
HEAT_VERSION_INCOMPATIBILITY_MAP = {'OS::Neutron::Port': {
|
|
'port_security_enabled': 'value_specs', }, }
|
|
|
|
HEAT_TEMPLATE_BASE = """
|
|
heat_template_version: 2013-05-23
|
|
"""
|
|
|
|
ALARMING_POLICY = 'tosca.policies.tacker.Alarming'
|
|
SCALING_POLICY = 'tosca.policies.tacker.Scaling'
|
|
|
|
|
|
def config_opts():
|
|
return [('openstack_vim', OPTS)]
|
|
|
|
|
|
class TOSCAToHOT(object):
|
|
"""Convert TOSCA template to HOT template."""
|
|
|
|
def __init__(self, vnf, heatclient, inst_req_info=None, grant_info=None):
|
|
self.vnf = vnf
|
|
self.heatclient = heatclient
|
|
self.attributes = {}
|
|
self.vnfd_yaml = None
|
|
self.unsupported_props = {}
|
|
self.heat_template_yaml = None
|
|
self.monitoring_dict = None
|
|
self.nested_resources = dict()
|
|
self.fields = None
|
|
self.STACK_FLAVOR_EXTRA = cfg.CONF.openstack_vim.flavor_extra_specs
|
|
self.appmonitoring_dict = None
|
|
self.grant_info = grant_info
|
|
self.inst_req_info = inst_req_info
|
|
|
|
@log.log
|
|
def generate_hot(self):
|
|
|
|
self._get_vnfd()
|
|
dev_attrs = self._update_fields()
|
|
vnfd_dict = yamlparser.simple_ordered_parse(self.vnfd_yaml)
|
|
LOG.debug('vnfd_dict %s', vnfd_dict)
|
|
self._get_unsupported_resource_props(self.heatclient)
|
|
|
|
self._generate_hot_from_tosca(vnfd_dict, dev_attrs,
|
|
self.inst_req_info, self.grant_info)
|
|
self.fields['template'] = self.heat_template_yaml
|
|
if not self.vnf['attributes'].get('heat_template'):
|
|
self.vnf['attributes']['heat_template'] = self.fields['template']
|
|
if self.monitoring_dict:
|
|
self.vnf['attributes'][
|
|
'monitoring_policy'] = jsonutils.dump_as_bytes(
|
|
self.monitoring_dict)
|
|
if self.appmonitoring_dict:
|
|
self.vnf['attributes']['app_monitoring_policy'] = \
|
|
jsonutils.dump_as_bytes(self.appmonitoring_dict)
|
|
|
|
@log.log
|
|
def _get_vnfd(self):
|
|
self.attributes = self.vnf['vnfd']['attributes'].copy()
|
|
self.vnfd_yaml = self.attributes.pop('vnfd', None)
|
|
if self.vnfd_yaml is None:
|
|
LOG.error("VNFD is not provided, so no vnf is created !!")
|
|
raise exceptions.InvalidInput("VNFD template is None.")
|
|
LOG.debug('vnfd_yaml %s', self.vnfd_yaml)
|
|
|
|
@log.log
|
|
def _update_fields(self):
|
|
attributes = self.attributes
|
|
fields = dict((key, attributes.pop(key)) for key
|
|
in ('stack_name', 'template_url', 'template')
|
|
if key in attributes)
|
|
for key in ('files', 'parameters'):
|
|
if key in attributes:
|
|
fields[key] = jsonutils.loads(attributes.pop(key))
|
|
|
|
# overwrite parameters with given dev_attrs for vnf creation
|
|
dev_attrs = self.vnf['attributes'].copy()
|
|
fields.update(dict((key, dev_attrs.pop(key)) for key
|
|
in ('stack_name', 'template_url', 'template')
|
|
if key in dev_attrs))
|
|
for key in ('files', 'parameters'):
|
|
if key in dev_attrs:
|
|
fields.setdefault(key, {}).update(
|
|
jsonutils.loads(dev_attrs.pop(key)))
|
|
|
|
self.attributes = attributes
|
|
self.fields = fields
|
|
return dev_attrs
|
|
|
|
@log.log
|
|
def _update_params(self, original, paramvalues, match=False):
|
|
for key, value in (original).items():
|
|
if not isinstance(value, dict) or 'get_input' not in str(value):
|
|
pass
|
|
elif isinstance(value, dict):
|
|
if not match:
|
|
if key in paramvalues and 'param' in paramvalues[key]:
|
|
self._update_params(value, paramvalues[key]['param'],
|
|
True)
|
|
elif key in paramvalues:
|
|
self._update_params(value, paramvalues[key], False)
|
|
else:
|
|
LOG.debug('Key missing Value: %s', key)
|
|
raise cs.InputValuesMissing(key=key)
|
|
elif 'get_input' in value:
|
|
if value['get_input'] in paramvalues:
|
|
original[key] = paramvalues[value['get_input']]
|
|
else:
|
|
LOG.debug('Key missing Value: %s', key)
|
|
raise cs.InputValuesMissing(key=key)
|
|
else:
|
|
self._update_params(value, paramvalues, True)
|
|
|
|
@log.log
|
|
def _process_parameterized_input(self, dev_attrs, vnfd_dict):
|
|
param_vattrs_yaml = dev_attrs.pop('param_values', None)
|
|
if param_vattrs_yaml:
|
|
try:
|
|
param_vattrs_dict = yaml.safe_load(param_vattrs_yaml)
|
|
LOG.debug('param_vattrs_yaml', param_vattrs_dict)
|
|
except Exception as e:
|
|
LOG.debug("Not Well Formed: %s", str(e))
|
|
raise vnfm.ParamYAMLNotWellFormed(
|
|
error_msg_details=str(e))
|
|
else:
|
|
self._update_params(vnfd_dict, param_vattrs_dict)
|
|
else:
|
|
raise cs.ParamYAMLInputMissing()
|
|
|
|
@log.log
|
|
def _process_vdu_network_interfaces(self, vdu_id, vdu_dict, properties,
|
|
template_dict):
|
|
|
|
networks_list = []
|
|
properties['networks'] = networks_list
|
|
for network_param in vdu_dict['network_interfaces'].values():
|
|
port = None
|
|
if 'addresses' in network_param:
|
|
ip_list = network_param.pop('addresses', [])
|
|
if not isinstance(ip_list, list):
|
|
raise vnfm.IPAddrInvalidInput()
|
|
mgmt_flag = network_param.pop('management', False)
|
|
port, template_dict =\
|
|
self._handle_port_creation(vdu_id, network_param,
|
|
template_dict,
|
|
ip_list, mgmt_flag)
|
|
if network_param.pop('management', False):
|
|
port, template_dict = self._handle_port_creation(vdu_id,
|
|
network_param,
|
|
template_dict,
|
|
[], True)
|
|
if port is not None:
|
|
network_param = {
|
|
'port': {'get_resource': port}
|
|
}
|
|
networks_list.append(dict(network_param))
|
|
return vdu_dict, template_dict
|
|
|
|
@log.log
|
|
def _make_port_dict(self):
|
|
port_dict = {'type': 'OS::Neutron::Port'}
|
|
if self.unsupported_props:
|
|
port_dict['properties'] = {
|
|
'value_specs': {
|
|
'port_security_enabled': False
|
|
}
|
|
}
|
|
else:
|
|
port_dict['properties'] = {
|
|
'port_security_enabled': False
|
|
}
|
|
port_dict['properties'].setdefault('fixed_ips', [])
|
|
return port_dict
|
|
|
|
@log.log
|
|
def _make_mgmt_outputs_dict(self, vdu_id, port, template_dict):
|
|
mgmt_ip = 'mgmt_ip-%s' % vdu_id
|
|
outputs_dict = template_dict['outputs']
|
|
outputs_dict[mgmt_ip] = {
|
|
'description': 'management ip address',
|
|
'value': {
|
|
'get_attr': [port, 'fixed_ips', 0, 'ip_address']
|
|
}
|
|
}
|
|
template_dict['outputs'] = outputs_dict
|
|
return template_dict
|
|
|
|
@log.log
|
|
def _handle_port_creation(self, vdu_id, network_param,
|
|
template_dict, ip_list=None,
|
|
mgmt_flag=False):
|
|
ip_list = ip_list or []
|
|
port = '%s-%s-port' % (vdu_id, network_param['network'])
|
|
port_dict = self._make_port_dict()
|
|
if mgmt_flag:
|
|
template_dict = self._make_mgmt_outputs_dict(vdu_id, port,
|
|
template_dict)
|
|
for ip in ip_list:
|
|
port_dict['properties']['fixed_ips'].append({"ip_address": ip})
|
|
port_dict['properties'].update(network_param)
|
|
template_dict['resources'][port] = port_dict
|
|
return port, template_dict
|
|
|
|
@log.log
|
|
def _get_unsupported_resource_props(self, heat_client):
|
|
unsupported_resource_props = {}
|
|
|
|
for res, prop_dict in (HEAT_VERSION_INCOMPATIBILITY_MAP).items():
|
|
unsupported_props = {}
|
|
for prop, val in (prop_dict).items():
|
|
if not heat_client.resource_attr_support(res, prop):
|
|
unsupported_props.update(prop_dict)
|
|
if unsupported_props:
|
|
unsupported_resource_props[res] = unsupported_props
|
|
self.unsupported_props = unsupported_resource_props
|
|
|
|
@log.log
|
|
def _generate_hot_from_tosca(self, vnfd_dict, dev_attrs,
|
|
inst_req_info=None,
|
|
grant_info=None):
|
|
parsed_params = {}
|
|
if 'param_values' in dev_attrs and dev_attrs['param_values'] != "":
|
|
try:
|
|
parsed_params = yaml.safe_load(dev_attrs['param_values'])
|
|
except Exception as e:
|
|
LOG.debug("Params not Well Formed: %s", str(e))
|
|
raise vnfm.ParamYAMLNotWellFormed(error_msg_details=str(e))
|
|
|
|
appmonitoring_dict = \
|
|
toscautils.get_vdu_applicationmonitoring(vnfd_dict)
|
|
|
|
block_storage_details = toscautils.get_block_storage_details(
|
|
vnfd_dict)
|
|
toscautils.updateimports(vnfd_dict)
|
|
if 'substitution_mappings' in str(vnfd_dict):
|
|
toscautils.check_for_substitution_mappings(
|
|
vnfd_dict,
|
|
parsed_params
|
|
)
|
|
|
|
try:
|
|
tosca = tosca_template.ToscaTemplate(parsed_params=parsed_params,
|
|
a_file=False,
|
|
yaml_dict_tpl=vnfd_dict)
|
|
|
|
except Exception as e:
|
|
LOG.debug("tosca-parser error: %s", str(e))
|
|
raise vnfm.ToscaParserFailed(error_msg_details=str(e))
|
|
|
|
unique_id = uuidutils.generate_uuid()
|
|
metadata = toscautils.get_vdu_metadata(tosca, unique_id=unique_id)
|
|
for policy in tosca.policies:
|
|
if policy.entity_tpl['type'] == constants.POLICY_RESERVATION:
|
|
metadata = toscautils.get_metadata_for_reservation(
|
|
tosca, metadata)
|
|
break
|
|
|
|
alarm_resources = toscautils.pre_process_alarm_resources(
|
|
self.vnf, tosca, metadata, unique_id=unique_id)
|
|
monitoring_dict = toscautils.get_vdu_monitoring(tosca)
|
|
mgmt_ports = toscautils.get_mgmt_ports(tosca)
|
|
res_tpl = toscautils.get_resources_dict(tosca,
|
|
self.STACK_FLAVOR_EXTRA)
|
|
toscautils.post_process_template(tosca)
|
|
scaling_policy_names = toscautils.get_scaling_policy(tosca)
|
|
try:
|
|
translator = tosca_translator.TOSCATranslator(tosca, parsed_params)
|
|
|
|
heat_template_yaml = translator.translate()
|
|
nested_resource_names = toscautils.get_nested_resources_name(
|
|
heat_template_yaml)
|
|
if nested_resource_names:
|
|
for nested_resource_name in nested_resource_names:
|
|
sub_heat_tmpl_name = \
|
|
toscautils.get_sub_heat_tmpl_name(nested_resource_name)
|
|
sub_heat_template_yaml =\
|
|
translator.translate_to_yaml_files_dict(
|
|
sub_heat_tmpl_name)
|
|
nested_resource_yaml = \
|
|
sub_heat_template_yaml[nested_resource_name]
|
|
LOG.debug("nested_resource_yaml: %s", nested_resource_yaml)
|
|
self.nested_resources[nested_resource_name] = \
|
|
nested_resource_yaml
|
|
|
|
except Exception as e:
|
|
LOG.debug("heat-translator error: %s", str(e))
|
|
raise vnfm.HeatTranslatorFailed(error_msg_details=str(e))
|
|
|
|
if self.nested_resources:
|
|
nested_tpl = toscautils.update_nested_scaling_resources(
|
|
self.nested_resources,
|
|
mgmt_ports, metadata, res_tpl, self.unsupported_props,
|
|
grant_info=grant_info, inst_req_info=inst_req_info)
|
|
self.fields['files'] = nested_tpl
|
|
for nested_resource_name in nested_tpl.keys():
|
|
self.vnf['attributes'][nested_resource_name] =\
|
|
nested_tpl[nested_resource_name]
|
|
mgmt_ports.clear()
|
|
|
|
if scaling_policy_names:
|
|
scaling_group_dict = toscautils.get_scaling_group_dict(
|
|
heat_template_yaml, scaling_policy_names)
|
|
self.vnf['attributes']['scaling_group_names'] =\
|
|
jsonutils.dump_as_bytes(scaling_group_dict)
|
|
|
|
if self.vnf['attributes'].get('maintenance', None):
|
|
toscautils.add_maintenance_resources(tosca, res_tpl)
|
|
|
|
heat_template_yaml = toscautils.post_process_heat_template(
|
|
heat_template_yaml, mgmt_ports, metadata, alarm_resources,
|
|
res_tpl, block_storage_details, self.unsupported_props,
|
|
unique_id=unique_id, inst_req_info=inst_req_info,
|
|
grant_info=grant_info, tosca=tosca)
|
|
|
|
try:
|
|
for nested_resource_name in self.nested_resources.keys():
|
|
self.nested_resources[nested_resource_name] = \
|
|
toscautils.post_process_heat_template_for_scaling(
|
|
self.nested_resources[nested_resource_name],
|
|
mgmt_ports, metadata, alarm_resources,
|
|
res_tpl, block_storage_details, self.unsupported_props,
|
|
unique_id=unique_id, inst_req_info=inst_req_info,
|
|
grant_info=grant_info, tosca=tosca)
|
|
except Exception as e:
|
|
LOG.debug("post_process_heat_template_for_scaling "
|
|
"error: %s", str(e))
|
|
raise
|
|
|
|
self.heat_template_yaml = heat_template_yaml
|
|
self.monitoring_dict = monitoring_dict
|
|
self.metadata = metadata
|
|
self.appmonitoring_dict = appmonitoring_dict
|
|
|
|
@log.log
|
|
def represent_odict(self, dump, tag, mapping, flow_style=None):
|
|
value = []
|
|
node = yaml.MappingNode(tag, value, flow_style=flow_style)
|
|
if dump.alias_key is not None:
|
|
dump.represented_objects[dump.alias_key] = node
|
|
best_style = True
|
|
if hasattr(mapping, 'items'):
|
|
mapping = mapping.items()
|
|
for item_key, item_value in mapping:
|
|
node_key = dump.represent_data(item_key)
|
|
node_value = dump.represent_data(item_value)
|
|
if not (isinstance(node_key, yaml.ScalarNode)
|
|
and not node_key.style):
|
|
best_style = False
|
|
if not (isinstance(node_value, yaml.ScalarNode)
|
|
and not node_value.style):
|
|
best_style = False
|
|
value.append((node_key, node_value))
|
|
if flow_style is None:
|
|
if dump.default_flow_style is not None:
|
|
node.flow_style = dump.default_flow_style
|
|
else:
|
|
node.flow_style = best_style
|
|
return node
|