Heat templates for deploying OpenStack
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

512 lines
20 KiB

#!/usr/bin/env python3
# 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.
import argparse
import collections
import openstack
import os
import re
import sys
import yaml
MIN_VIABLE_MTU_HEADER = (
"{% set mtu_list = [ctlplane_mtu] %}\n"
"{% for network in role_networks %}\n"
"{{ mtu_list.append(lookup('vars', networks_lower[network] ~ '_mtu')) }}\n"
"{%- endfor %}\n"
"{% set min_viable_mtu = mtu_list | max %}\n"
)
DUAL_MIN_VIABLE_MTU_HEADER = (
"{% set mtu_ctlplane_list = [ctlplane_mtu] %}\n"
"{% set mtu_dataplane_list = [] %}\n"
"{% for network in role_networks %}\n"
"{# This block resolves the minimum viable MTU for interfaces connected to #}\n" # noqa
"{# the dataplane network(s), which start by Tenant, and also bonds #}\n"
"{# and bridges that carry multiple VLANs. Each VLAN may have different MTU. #}\n" # noqa
"{# The bridge, bond or interface must have an MTU to allow the VLAN with the #}\n" # noqa
"{# largest MTU. #}\n"
"{% if network.startswith('Tenant') %}\n"
"{{ mtu_dataplane_list.append(lookup('vars', networks_lower[network] ~ '_mtu')) }}\n" # noqa
"{# This block resolves the minimum viable MTU for interfaces connected to #}\n" # noqa
"{# the control plane network(s) (don't start by Tenant), and also bonds #}\n" # noqa
"{# and bridges that carry multiple VLANs. Each VLAN may have different MTU. #}\n" # noqa
"{# The bridge, bond or interface must have an MTU to allow the VLAN with the #}\n" # noqa
"{# largest MTU. #}\n"
"{% else %}\n"
"{{ mtu_ctlplane_list.append(lookup('vars', networks_lower[network] ~ '_mtu')) }}\n" # noqa
"{%- endfor %}\n"
"{% set min_viable_mtu_ctlplane = mtu_ctlplane_list | max %}\n"
"{% set min_viable_mtu_dataplane = mtu_dataplane_list | max %}\n"
)
UNSUPPORTED_HEAT_INTRINSIC_FUNCTIONS = {
'get_file', 'get_resource', 'digest', 'repeat', 'resource_facade',
'str_replace', 'str_replace_strict', 'str_split', 'map_merge',
'map_replace', 'yaql', 'equals', 'if', 'not', 'and', 'or', 'filter',
'make_url', 'contains'
}
QUOTE_FIX = '%_fix_quote_%'
DBL_QUOTE_FIX = '%_double_fix_quote_%'
def parse_opts(argv):
parser = argparse.ArgumentParser(
description='Convert to Ansible Jinja2 NIC config templates.')
parser.add_argument('--stack',
metavar='STACK_NAME',
help='Name or ID of heat stack (default=overcloud)',
default='overcloud')
parser.add_argument('-n', '--networks_file',
metavar='<network_data.yaml>',
required=True,
help=('Configuration file describing the network '
'deployment.'))
parser.add_argument('-y', '--yes',
default=False,
action='store_true',
help='Overwrite existing files.')
parser.add_argument('template',
metavar='TEMPLATE_FILE',
help='Existing NIC config template to convert.')
opts = parser.parse_args(argv[1:])
return opts
class TemplateDumper(yaml.SafeDumper):
def represent_ordered_dict(self, data):
return self.represent_dict(data.items())
class TemplateLoader(yaml.SafeLoader):
def construct_mapping(self, node):
self.flatten_mapping(node)
return collections.OrderedDict(self.construct_pairs(node))
TemplateDumper.add_representer(collections.OrderedDict,
TemplateDumper.represent_ordered_dict)
TemplateLoader.add_constructor(yaml.BaseLoader,
TemplateLoader.construct_mapping)
class ConvertToAnsibleJ2(object):
def __init__(self, stack_env, networks_file):
self.stack_env = stack_env
self.param_to_var_map = self.create_param_to_var_map(networks_file)
self.hard_coded_parameters = list()
@staticmethod
def unwrap_j2_var(x):
"""Strip jinja2 brackets from string
When nesting ansible vars in jinja2 the brackets must be
removed. This also adds appropriate quote fix prefix and
suffix.
"""
is_ansible_var = False
if isinstance(x, str):
if x.startswith('{{ ') and x.endswith(' }}'):
is_ansible_var = True
x = x[3:]
x = x[:-3]
else:
raise RuntimeError(
'Unsupported type {} for method unwrap_j2_var'.format(type(x)))
if is_ansible_var:
return DBL_QUOTE_FIX + '{}'.format(x) + DBL_QUOTE_FIX
else:
return QUOTE_FIX + '{}'.format(x) + QUOTE_FIX
@staticmethod
def strip_j2_comment(x):
"""Strip jinja2 comment from string
When nesting hard-coded parameter conversions in jinja2 the
comment must be removed.
"""
return re.sub('{#.*#}', '', x)
def normalize_complex(self, old):
if isinstance(old, list):
new = list()
for i in old:
if isinstance(i, str):
new.append(self.strip_j2_comment(self.unwrap_j2_var(i)))
if isinstance(i, (bool, int)):
new.append(i)
if isinstance(i, (list, dict)):
new.append(self.normalize_complex(i))
elif isinstance(old, dict):
new = dict()
for k, v in old.items():
k = QUOTE_FIX + '{}'.format(k) + QUOTE_FIX
if isinstance(v, str):
new[k] = self.strip_j2_comment(self.unwrap_j2_var(v))
if isinstance(v, (bool, int)):
new[k] = v
if isinstance(v, (list, dict)):
new[k] = self.normalize_complex(v)
else:
raise RuntimeError(
'Unsupported type {} for method normalize_complex'.format(
type(old)))
return new
@staticmethod
def to_j2_var(x):
if not isinstance(x, str):
raise RuntimeError(
'Unsupported type {} for method to_j2_var'.format(type(x)))
return '{{{{ {} }}}}'.format(x)
@staticmethod
def quote_fix(x):
return QUOTE_FIX + '{}'.format(x) + QUOTE_FIX
def create_param_to_var_map(self, networks_file):
_map = {
'ControlPlaneIp': self.to_j2_var('ctlplane_ip'),
'ControlPlaneSubnetCidr': self.to_j2_var('ctlplane_subnet_cidr'),
'ControlPlaneMtu': self.to_j2_var('ctlplane_mtu'),
'ControlPlaneDefaultRoute': self.to_j2_var('ctlplane_gateway_ip'),
'ControlPlaneStaticRoutes': self.to_j2_var('ctlplane_host_routes'),
'DnsServers': self.to_j2_var('ctlplane_dns_nameservers'),
'DnsSearchDomains': self.to_j2_var('dns_search_domains'),
'NumDpdkInterfaceRxQueues':
self.to_j2_var('num_dpdk_interface_rx_queues'),
'BondInterfaceOvsOptions':
self.to_j2_var('bond_interface_ovs_options')
}
with open(networks_file, 'r') as f:
networks = yaml.safe_load(f.read())
for net in networks:
name = net['name']
name_lower = net.get('name_lower', net['name'].lower())
_map.update({
name + 'NetworkVlanID':
self.to_j2_var('{}_vlan_id'.format(name_lower)),
name + 'IpSubnet':
'/'.join([self.to_j2_var('{}_ip'.format(name_lower)),
self.to_j2_var('{}_cidr'.format(name_lower))]),
name + 'InterfaceDefaultRoute':
self.to_j2_var('{}_gateway_ip'.format(name_lower)),
name + 'InterfaceRoutes':
self.to_j2_var('{}_host_routes'.format(name_lower)),
name + 'Mtu':
self.to_j2_var('{}_mtu'.format(name_lower))
})
return _map
def convert_get_param(self, old):
param = old['get_param']
if isinstance(param, str):
if param in self.param_to_var_map:
return self.param_to_var_map[param]
elif param in self.stack_env.get('parameter_defaults', {}):
stack_value = self.stack_env['parameter_defaults'][param]
print('INFO - Custom Parameter {} was hard-coded in the '
'converted template using the value from the Heat stack '
'environment.\n'
' To parameterize the value an ansible var must be '
'added using the {{role.name}}ExtraGroupVars '
'THT interface and the template modified to use the '
'ansible var.'.format(param))
j2_comment = (
'{{# NOTE! Custom parameter {} was hard-coded in '
'the converted template. To parameterize use the '
'{{role.name}}ExtraGroupVars THT interface and update the '
'template to use an ansible var. #}}'.format(param))
self.hard_coded_parameters.append(param)
if isinstance(stack_value, str):
return self.quote_fix(stack_value + j2_comment)
else:
return stack_value
else:
print('WARNING - Manual intervention required. Unable to '
'convert get_param occurrence: {}'.format(old))
return self.quote_fix(
'NEED MANUAL CONVERSION: {}'.format(str(old)))
elif isinstance(param, list):
print('WARNING - can not convert get_param referencing values in '
'complex datastructures. Please review the Ansible Jinja2 '
'template and convert this manually.')
return self.quote_fix(
'NEED MANUAL CONVERSION: {}'.format(str(old)))
raise RuntimeError(
'Unexpected Type {} in get_param: {}'.format(type(param), old))
def convert_get_attr(self, old):
attr = old['get_attr']
if not isinstance(attr, list):
raise RuntimeError(
'Attributes for get_attr convertsion must of type list.')
if 'MinViableMtu' in attr:
return self.to_j2_var('min_viable_mtu')
elif 'MinViableMtuBondApi' in attr:
return self.to_j2_var('min_viable_mtu_ctlplane')
elif 'MinViableMtuBondData' in attr:
return self.to_j2_var('min_viable_mtu_dataplane')
else:
print('WARNING - only MinViableMtu and combined '
'MinViableMtuBondApi + MinViableMtuBondData attribute can '
'be converted. Please review the Ansible Jinja2 template '
'and convert this manually.')
return 'NEED MANUAL CONVERSION: {}'.format(str(old))
def convert_list_join(self, list_join_attrs):
to_join = list()
for x in list_join_attrs[1]:
to_join.append(self.recursive_convert(x))
return list_join_attrs[0].join(to_join)
def convert_list_concat(self, list_concat_attrs):
ansible_concat_tpl = "{} | flatten"
to_concatenate = list()
if not isinstance(list_concat_attrs, list):
raise RuntimeError('list_concat_args must be a list')
for x in list_concat_attrs:
to_concatenate.append(self.recursive_convert(x))
to_concatenate = self.normalize_complex(to_concatenate)
new = ansible_concat_tpl.format(to_concatenate)
return self.to_j2_var(new)
def convert_list_concat_unique(self, list_concat_unique_attrs):
ansible_concat_unique_tpl = "{} | flatten | unique"
to_concatenate = list()
if not isinstance(list_concat_unique_attrs, list):
raise RuntimeError('list_concat_unique_attrs must be a list')
for x in list_concat_unique_attrs:
to_concatenate.append(self.recursive_convert(x))
to_concatenate = self.normalize_complex(to_concatenate)
new = ansible_concat_unique_tpl.format(to_concatenate)
return self.to_j2_var(new)
@staticmethod
def convert_unsupported(old, fn):
print('WARNING - can not convert unsupported heat intrinsic function '
' {}. Please review the Ansible Jinja2 template and convert '
'this manually.'.format(fn))
return ('UNSUPPORTED HEAT INTRINSIC FUNCTION {} '
'REQUIRES MANUAL CONVERSION {}'.format(fn, old))
def recursive_convert(self, old):
if isinstance(old, (bool, str, int)):
new = old
elif isinstance(old, dict):
for fn in UNSUPPORTED_HEAT_INTRINSIC_FUNCTIONS:
if fn in old:
return self.convert_unsupported(old, fn)
if 'get_param' in old:
return self.convert_get_param(old)
elif 'get_attr' in old:
return self.convert_get_attr(old)
elif 'list_join' in old:
return self.convert_list_join(old['list_join'])
elif 'list_concat_unique' in old:
return self.convert_list_concat_unique(
old['list_concat_unique'])
else:
new = collections.OrderedDict()
for k, v in old.items():
if isinstance(v, (bool, str, int)):
new[k] = v
elif isinstance(v, (list, dict)):
new[k] = self.recursive_convert(v)
else:
raise RuntimeError(
'Unexpected Type {} for key: {}'.format(
type(v), k))
elif isinstance(old, list):
new = list()
for x in old:
new.append(self.recursive_convert(x))
else:
raise RuntimeError(
'Unknown type {} for recursive convert'.format(type(old)))
return new
def convert_template(self, template):
with open(template, 'r') as f:
heat_tpl = yaml.safe_load(f.read())
resources = set(heat_tpl['resources'].keys())
if not resources.issubset({'OsNetConfigImpl',
'MinViableMtu',
'MinViableMtuBondApi',
'MinViableMtuBondData'}):
msg = ('Only OsNetConfigImpl and MinViableMtu resoureces '
'supported. Found resources: {}'.format(resources))
raise RuntimeError(msg)
net_config_res = heat_tpl['resources'].get('OsNetConfigImpl')
mtu_header = None
if heat_tpl['resources'].get('MinViableMtu'):
mtu_header = 'single'
elif (heat_tpl['resources'].get('MinViableMtuBondApi')
and heat_tpl['resources'].get('MinViableMtuBondData')):
mtu_header = 'dual'
if not net_config_res:
raise RuntimeError('OsNetConfigImpl resource not found in '
'template.')
net_config_res_props = net_config_res['properties']
if net_config_res['type'] == 'OS::Heat::Value':
h_net_conf = net_config_res_props['value']
elif net_config_res['type'] == 'OS::Heat::SoftwareConfig':
h_net_conf = net_config_res_props['config']['str_replace'][
'params']['$network_config']['network_config']
else:
raise RuntimeError('No network config found in provided template.')
j2_config = collections.OrderedDict({'network_config': []})
j2_net_conf = j2_config['network_config']
j2_net_conf.extend(self.recursive_convert(h_net_conf))
j2_header = None
if self.hard_coded_parameters:
j2_header = (
'{# The values of the following custom heat parameters was '
'hard-coded into this template:\n')
for param in self.hard_coded_parameters:
j2_header += ' * {}\n'.format(param)
j2_header += (
'To parameterize use the {{role.name}}ExtraGroupVars THT '
'interface and update the template to use an ansible var.\n'
'#}\n')
return j2_config, mtu_header, j2_header
def write_j2_template(j2_template, j2_config, mtu_header, j2_header):
"""Write the Jinja2 template file
This is done in three steps because the YAML dumper insists
to add quotes:
write the template file
read the template file
re-write it with quotes removed
"""
with open(j2_template, 'w') as f:
if j2_header:
f.write(j2_header)
f.write('---\n')
if mtu_header:
if mtu_header == 'single':
f.write(MIN_VIABLE_MTU_HEADER)
elif mtu_header == 'dual':
f.write(DUAL_MIN_VIABLE_MTU_HEADER)
yaml.dump(j2_config, f, TemplateDumper, width=256,
default_flow_style=False)
with open(j2_template, 'r') as f:
data = f.read()
# Remove quote before jinja2 var reference
data = data.replace('\'{{', '{{')
# Remove quote after jinja2 var reference
data = data.replace('}}\'', '}}')
# Remove quote before value imported from stack environment
data = data.replace('\'' + QUOTE_FIX, '')
# Remove quote after value imported from stack environment
data = data.replace(QUOTE_FIX + '\'', '')
# Remove quote before value imported from stack environment
data = data.replace('\'\'' + DBL_QUOTE_FIX, '')
# Remove quote after value imported from stack environment
data = data.replace(DBL_QUOTE_FIX + '\'\'', '')
# Remove quote_fix string
data = data.replace(QUOTE_FIX, '')
data = data.replace(DBL_QUOTE_FIX, '')
with open(j2_template, 'w') as f:
f.write(data)
def validate_files(opts, template, networks_file, j2_template):
if not os.path.exists(template):
raise RuntimeError('Template file not found {}.'.format(template))
if not os.path.isfile(template):
raise RuntimeError('Template {} is not a file.'.format(template))
if not os.path.exists(networks_file):
raise RuntimeError('Networks file not found, {}.'.format(
networks_file))
if not os.path.isfile(networks_file):
raise RuntimeError('Networks file {} is not a file.'.format(
networks_file))
if os.path.exists(j2_template) and not opts.yes:
raise RuntimeError('Ansible Jinja2 template {} already exists'.format(
j2_template))
if os.path.exists(j2_template) and not os.path.isfile(j2_template):
raise RuntimeError('Existing {} is not a file.'.format(j2_template))
pass
def get_stack_environment(stack_name):
try:
conn = openstack.connect('undercloud')
stack = conn.orchestration.find_stack(stack_name)
if not stack:
print('INFO: Heat stack {} not found.'.format(stack_name))
return {}
stack_env = conn.orchestration.get_stack_environment(stack)
except Exception as e:
print('ERROR: Unable to get stack environment.')
raise e
return stack_env
def main():
opts = parse_opts(sys.argv)
template = os.path.abspath(opts.template)
networks_file = os.path.abspath(opts.networks_file)
j2_template = os.path.splitext(template)[0] + '.j2'
validate_files(opts, template, networks_file, j2_template)
stack_env = get_stack_environment(opts.stack)
converter = ConvertToAnsibleJ2(stack_env, networks_file)
j2_config, mtu_header, j2_header = converter.convert_template(template)
write_j2_template(j2_template, j2_config, mtu_header, j2_header)
if __name__ == '__main__':
main()