224 lines
7.2 KiB
Python
224 lines
7.2 KiB
Python
# vim: set ts=4:et
|
|
import os
|
|
import uuid
|
|
from charmhelpers.core.hookenv import (
|
|
log, ERROR,
|
|
config,
|
|
relation_get,
|
|
relation_ids,
|
|
related_units,
|
|
unit_get,
|
|
network_get_primary_address,
|
|
)
|
|
from charmhelpers.contrib.openstack.context import (
|
|
OSContextGenerator,
|
|
NeutronAPIContext,
|
|
config_flags_parser,
|
|
)
|
|
from charmhelpers.contrib.openstack.utils import (
|
|
os_release,
|
|
CompareOpenStackReleases,
|
|
)
|
|
from charmhelpers.contrib.hahelpers.cluster import (
|
|
eligible_leader
|
|
)
|
|
|
|
from charmhelpers.contrib.network.ip import (
|
|
get_address_in_network,
|
|
get_host_ip,
|
|
)
|
|
|
|
NEUTRON_ML2_PLUGIN = "ml2"
|
|
NEUTRON_N1KV_PLUGIN = \
|
|
"neutron.plugins.cisco.n1kv.n1kv_neutron_plugin.N1kvNeutronPluginV2"
|
|
NEUTRON_NSX_PLUGIN = "vmware"
|
|
NEUTRON_OVS_ODL_PLUGIN = "ml2"
|
|
|
|
OVS = 'ovs'
|
|
N1KV = 'n1kv'
|
|
NSX = 'nsx'
|
|
OVS_ODL = 'ovs-odl'
|
|
|
|
NEUTRON = 'neutron'
|
|
|
|
CORE_PLUGIN = {
|
|
OVS: NEUTRON_ML2_PLUGIN,
|
|
N1KV: NEUTRON_N1KV_PLUGIN,
|
|
NSX: NEUTRON_NSX_PLUGIN,
|
|
OVS_ODL: NEUTRON_OVS_ODL_PLUGIN,
|
|
}
|
|
|
|
|
|
def _get_availability_zone():
|
|
from neutron_utils import get_availability_zone as get_az
|
|
return get_az()
|
|
|
|
|
|
def core_plugin():
|
|
return CORE_PLUGIN[config('plugin')]
|
|
|
|
|
|
def get_local_ip():
|
|
fallback = get_host_ip(unit_get('private-address'))
|
|
if config('os-data-network'):
|
|
# NOTE: prefer any existing use of config based networking
|
|
local_ip = get_address_in_network(
|
|
config('os-data-network'),
|
|
fallback)
|
|
else:
|
|
# NOTE: test out network-spaces support, then fallback
|
|
try:
|
|
local_ip = get_host_ip(network_get_primary_address('data'))
|
|
except NotImplementedError:
|
|
local_ip = fallback
|
|
return local_ip
|
|
|
|
|
|
class L3AgentContext(OSContextGenerator):
|
|
|
|
def __call__(self):
|
|
api_settings = NeutronAPIContext()()
|
|
ctxt = {}
|
|
if config('run-internal-router') == 'leader':
|
|
ctxt['handle_internal_only_router'] = eligible_leader(None)
|
|
|
|
if config('run-internal-router') == 'all':
|
|
ctxt['handle_internal_only_router'] = True
|
|
|
|
if config('run-internal-router') == 'none':
|
|
ctxt['handle_internal_only_router'] = False
|
|
|
|
if config('external-network-id'):
|
|
ctxt['ext_net_id'] = config('external-network-id')
|
|
|
|
if not config('ext-port') and not config('external-network-id'):
|
|
ctxt['external_configuration_new'] = True
|
|
|
|
if config('plugin'):
|
|
ctxt['plugin'] = config('plugin')
|
|
if api_settings['enable_dvr']:
|
|
ctxt['agent_mode'] = 'dvr_snat'
|
|
else:
|
|
ctxt['agent_mode'] = 'legacy'
|
|
ctxt['rpc_response_timeout'] = api_settings['rpc_response_timeout']
|
|
ctxt['report_interval'] = api_settings['report_interval']
|
|
ctxt['use_l3ha'] = api_settings['enable_l3ha']
|
|
return ctxt
|
|
|
|
|
|
class NeutronGatewayContext(NeutronAPIContext):
|
|
|
|
def __call__(self):
|
|
api_settings = super(NeutronGatewayContext, self).__call__()
|
|
ctxt = {
|
|
'shared_secret': get_shared_secret(),
|
|
'core_plugin': core_plugin(),
|
|
'plugin': config('plugin'),
|
|
'debug': config('debug'),
|
|
'verbose': config('verbose'),
|
|
'instance_mtu': config('instance-mtu'),
|
|
'dns_servers': config('dns-servers'),
|
|
'l2_population': api_settings['l2_population'],
|
|
'enable_dvr': api_settings['enable_dvr'],
|
|
'enable_l3ha': api_settings['enable_l3ha'],
|
|
'extension_drivers': api_settings['extension_drivers'],
|
|
'dns_domain': api_settings['dns_domain'],
|
|
'overlay_network_type':
|
|
api_settings['overlay_network_type'],
|
|
'rpc_response_timeout': api_settings['rpc_response_timeout'],
|
|
'report_interval': api_settings['report_interval'],
|
|
'enable_metadata_network': config('enable-metadata-network'),
|
|
'enable_isolated_metadata': config('enable-isolated-metadata'),
|
|
'availability_zone': _get_availability_zone(),
|
|
}
|
|
|
|
ctxt['local_ip'] = get_local_ip()
|
|
mappings = config('bridge-mappings')
|
|
if mappings:
|
|
ctxt['bridge_mappings'] = ','.join(mappings.split())
|
|
|
|
flat_providers = config('flat-network-providers')
|
|
if flat_providers:
|
|
ctxt['network_providers'] = ','.join(flat_providers.split())
|
|
|
|
vlan_ranges = config('vlan-ranges')
|
|
if vlan_ranges:
|
|
ctxt['vlan_ranges'] = ','.join(vlan_ranges.split())
|
|
|
|
dnsmasq_flags = config('dnsmasq-flags')
|
|
if dnsmasq_flags:
|
|
ctxt['dnsmasq_flags'] = config_flags_parser(dnsmasq_flags)
|
|
|
|
net_dev_mtu = api_settings['network_device_mtu']
|
|
if net_dev_mtu:
|
|
ctxt['network_device_mtu'] = net_dev_mtu
|
|
ctxt['veth_mtu'] = net_dev_mtu
|
|
|
|
# Override user supplied config for these plugins as these settings are
|
|
# mandatory
|
|
if ctxt['plugin'] in ['nvp', 'nsx', 'n1kv']:
|
|
ctxt['enable_metadata_network'] = True
|
|
ctxt['enable_isolated_metadata'] = True
|
|
|
|
return ctxt
|
|
|
|
|
|
class NovaMetadataContext(OSContextGenerator):
|
|
|
|
def __init__(self, rel_name='quantum-network-service'):
|
|
self.rel_name = rel_name
|
|
self.interfaces = [rel_name]
|
|
|
|
def __call__(self):
|
|
ctxt = {}
|
|
cmp_os_release = CompareOpenStackReleases(os_release('neutron-common'))
|
|
if cmp_os_release < 'rocky':
|
|
vdata_providers = []
|
|
vdata = config('vendor-data')
|
|
vdata_url = config('vendor-data-url')
|
|
|
|
if vdata:
|
|
ctxt['vendor_data'] = True
|
|
vdata_providers.append('StaticJSON')
|
|
|
|
if vdata_url:
|
|
if cmp_os_release > 'mitaka':
|
|
ctxt['vendor_data_url'] = vdata_url
|
|
vdata_providers.append('DynamicJSON')
|
|
else:
|
|
log('Dynamic vendor data unsupported'
|
|
' for {}.'.format(cmp_os_release), level=ERROR)
|
|
ctxt['vendordata_providers'] = ','.join(vdata_providers)
|
|
for rid in relation_ids(self.rel_name):
|
|
for unit in related_units(rid):
|
|
rdata = relation_get(rid=rid, unit=unit)
|
|
secret = rdata.get('shared-metadata-secret')
|
|
if secret:
|
|
ctxt['shared_secret'] = secret
|
|
ctxt['nova_metadata_host'] = rdata['nova-metadata-host']
|
|
ctxt['nova_metadata_port'] = rdata['nova-metadata-port']
|
|
ctxt['nova_metadata_protocol'] = rdata[
|
|
'nova-metadata-protocol']
|
|
if not ctxt.get('shared_secret'):
|
|
ctxt['shared_secret'] = get_shared_secret()
|
|
ctxt['nova_metadata_host'] = get_local_ip()
|
|
ctxt['nova_metadata_port'] = '8775'
|
|
ctxt['nova_metadata_protocol'] = 'http'
|
|
return ctxt
|
|
|
|
|
|
SHARED_SECRET = "/etc/{}/secret.txt"
|
|
|
|
|
|
def get_shared_secret():
|
|
secret = None
|
|
_path = SHARED_SECRET.format(NEUTRON)
|
|
if not os.path.exists(_path):
|
|
secret = str(uuid.uuid4())
|
|
with open(_path, 'w') as secret_file:
|
|
secret_file.write(secret)
|
|
else:
|
|
with open(_path, 'r') as secret_file:
|
|
secret = secret_file.read().strip()
|
|
return secret
|