No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/python/vyos/configverify.py b/python/vyos/configverify.py
	index de88310e8..abd91583d 100644
	--- a/python/vyos/configverify.py
	+++ b/python/vyos/configverify.py
	@@ -1,330 +1,332 @@
	# Copyright 2020 VyOS maintainers and contributors <maintainers@vyos.io>
	#
	# This library is free software; you can redistribute it and/or
	# modify it under the terms of the GNU Lesser General Public
	# License as published by the Free Software Foundation; either
	# version 2.1 of the License, or (at your option) any later version.
	#
	# This library is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	# Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU Lesser General Public
	# License along with this library. If not, see <http://www.gnu.org/licenses/>.

	# The sole purpose of this module is to hold common functions used in
	# all kinds of implementations to verify the CLI configuration.
	# It is started by migrating the interfaces to the new get_config_dict()
	# approach which will lead to a lot of code that can be reused.

	# NOTE: imports should be as local as possible to the function which
	# makes use of it!

	from vyos import ConfigError
	from vyos.util import dict_search

	def verify_mtu(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if the specified MTU can be used by the underlaying
	hardware.
	"""
	from vyos.ifconfig import Interface
	if 'mtu' in config:
	mtu = int(config['mtu'])

	tmp = Interface(config['ifname'])
	min_mtu = tmp.get_min_mtu()
	max_mtu = tmp.get_max_mtu()

	if mtu < min_mtu:
	raise ConfigError(f'Interface MTU too low, ' \
	f'minimum supported MTU is {min_mtu}!')
	if mtu > max_mtu:
	raise ConfigError(f'Interface MTU too high, ' \
	f'maximum supported MTU is {max_mtu}!')

	def verify_mtu_ipv6(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if the specified MTU can be used when IPv6 is
	configured on the interface. IPv6 requires a 1280 bytes MTU.
	"""
	from vyos.template import is_ipv6
	if 'mtu' in config:
	# IPv6 minimum required link mtu
	min_mtu = 1280
	if int(config['mtu']) < min_mtu:
	interface = config['ifname']
	error_msg = f'IPv6 address will be configured on interface "{interface}" ' \
	f'thus the minimum MTU requirement is {min_mtu}!'

	for address in (dict_search('address', config) or []):
	if address in ['dhcpv6'] or is_ipv6(address):
	raise ConfigError(error_msg)

	tmp = dict_search('ipv6.address', config)
	if tmp and 'no_default_link_local' not in tmp:
	raise ConfigError('link-local ' + error_msg)

	if tmp and 'autoconf' in tmp:
	raise ConfigError(error_msg)

	if tmp and 'eui64' in tmp:
	raise ConfigError(error_msg)

	def verify_vrf(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of VRF configuration.
	"""
	from netifaces import interfaces
	if 'vrf' in config:
	if config['vrf'] not in interfaces():
	raise ConfigError('VRF "{vrf}" does not exist'.format(**config))

	if 'is_bridge_member' in config:
	raise ConfigError(
	'Interface "{ifname}" cannot be both a member of VRF "{vrf}" '
	'and bridge "{is_bridge_member}"!'.format(**config))

	def verify_eapol(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of EAPoL configuration.
	"""
	if 'eapol' in config:
	if not {'cert_file', 'key_file'} <= set(config['eapol']):
	raise ConfigError('Both cert and key-file must be specified '\
	'when using EAPoL!')

	def verify_mirror(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of mirror interface configuration.

	It makes no sense to mirror traffic back at yourself!
	"""
	if 'mirror' in config:
	for direction, mirror_interface in config['mirror'].items():
	if mirror_interface == config['ifname']:
	raise ConfigError(f'Can not mirror "{direction}" traffic back ' \
	'the originating interface!')


	def verify_address(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of IP address assignment when interface is part
	of a bridge or bond.
	"""
	if {'is_bridge_member', 'address'} <= set(config):
	raise ConfigError(
	'Cannot assign address to interface "{ifname}" as it is a '
	'member of bridge "{is_bridge_member}"!'.format(**config))


	def verify_bridge_delete(config):
	"""
	Common helper function used by interface implementations to
	perform recurring validation of IP address assignmenr
	when interface also is part of a bridge.
	"""
	if 'is_bridge_member' in config:
	raise ConfigError(
	'Interface "{ifname}" cannot be deleted as it is a '
	'member of bridge "{is_bridge_member}"!'.format(**config))

	def verify_interface_exists(ifname):
	"""
	Common helper function used by interface implementations to perform
	recurring validation if an interface actually exists.
	"""
	from netifaces import interfaces
	if ifname not in interfaces():
	raise ConfigError(f'Interface "{ifname}" does not exist!')

	def verify_source_interface(config):
	"""
	Common helper function used by interface implementations to
	perform recurring validation of the existence of a source-interface
	required by e.g. peth/MACvlan, MACsec ...
	"""
	from netifaces import interfaces
	if 'source_interface' not in config:
	raise ConfigError('Physical source-interface required for '
	'interface "{ifname}"'.format(**config))

	if config['source_interface'] not in interfaces():
	raise ConfigError('Specified source-interface {source_interface} does '
	'not exist'.format(**config))

	if 'source_interface_is_bridge_member' in config:
	raise ConfigError('Invalid source-interface {source_interface}. Interface '
	'is already a member of bridge '
	'{source_interface_is_bridge_member}'.format(**config))

	if 'source_interface_is_bond_member' in config:
	raise ConfigError('Invalid source-interface {source_interface}. Interface '
	'is already a member of bond '
	'{source_interface_is_bond_member}'.format(**config))

	def verify_dhcpv6(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of DHCPv6 options which are mutually exclusive.
	"""
	if 'dhcpv6_options' in config:
	from vyos.util import dict_search

	if {'parameters_only', 'temporary'} <= set(config['dhcpv6_options']):
	raise ConfigError('DHCPv6 temporary and parameters-only options '
	'are mutually exclusive!')

	# It is not allowed to have duplicate SLA-IDs as those identify an
	# assigned IPv6 subnet from a delegated prefix
	for pd in dict_search('dhcpv6_options.pd', config):
	sla_ids = []
	interfaces = dict_search(f'dhcpv6_options.pd.{pd}.interface', config)

	if not interfaces:
	raise ConfigError('DHCPv6-PD requires an interface where to assign '
	'the delegated prefix!')

	for count, interface in enumerate(interfaces):
	if 'sla_id' in interfaces[interface]:
	sla_ids.append(interfaces[interface]['sla_id'])
	else:
	sla_ids.append(str(count))

	# Check for duplicates
	duplicates = [x for n, x in enumerate(sla_ids) if x in sla_ids[:n]]
	if duplicates:
	raise ConfigError('Site-Level Aggregation Identifier (SLA-ID) '
	'must be unique per prefix-delegation!')

	def verify_vlan_config(config):
	"""
	Common helper function used by interface implementations to perform
	recurring validation of interface VLANs
	"""
	# 802.1q VLANs
	for vlan in config.get('vif', {}):
	vlan = config['vif'][vlan]
	verify_dhcpv6(vlan)
	verify_address(vlan)
	verify_vrf(vlan)

	# 802.1ad (Q-in-Q) VLANs
	for vlan in config.get('vif_s', {}):
	vlan = config['vif_s'][vlan]
	verify_dhcpv6(vlan)
	verify_address(vlan)
	verify_vrf(vlan)

	for vlan in config.get('vif_s', {}).get('vif_c', {}):
	vlan = config['vif_c'][vlan]
	verify_dhcpv6(vlan)
	verify_address(vlan)
	verify_vrf(vlan)

	def verify_accel_ppp_base_service(config):
	"""
	Common helper function which must be used by all Accel-PPP services based
	on get_config_dict()
	"""
	# vertify auth settings
	if dict_search('authentication.mode', config) == 'local':
	if not dict_search('authentication.local_users', config):
	raise ConfigError('PPPoE local auth mode requires local users to be configured!')

	for user in dict_search('authentication.local_users.username', config):
	user_config = config['authentication']['local_users']['username'][user]

	if 'password' not in user_config:
	raise ConfigError(f'Password required for local user "{user}"')

	if 'rate_limit' in user_config:
	# if up/download is set, check that both have a value
	if not {'upload', 'download'} <= set(user_config['rate_limit']):
	raise ConfigError(f'User "{user}" has rate-limit configured for only one ' \
	'direction but both upload and download must be given!')

	elif dict_search('authentication.mode', config) == 'radius':
	if not dict_search('authentication.radius.server', config):
	raise ConfigError('RADIUS authentication requires at least one server')

	for server in dict_search('authentication.radius.server', config):
	radius_config = config['authentication']['radius']['server'][server]
	if 'key' not in radius_config:
	raise ConfigError(f'Missing RADIUS secret key for server "{server}"')

	if 'gateway_address' not in config:
	raise ConfigError('PPPoE server requires gateway-address to be configured!')

	if 'name_server_ipv4' in config:
	if len(config['name_server_ipv4']) > 2:
	raise ConfigError('Not more then two IPv4 DNS name-servers ' \
	'can be configured')

	if 'name_server_ipv6' in config:
	if len(config['name_server_ipv6']) > 3:
	raise ConfigError('Not more then three IPv6 DNS name-servers ' \
	'can be configured')

	if 'client_ipv6_pool' in config:
	ipv6_pool = config['client_ipv6_pool']
	if 'delegate' in ipv6_pool:
	if 'prefix' not in ipv6_pool:
	raise ConfigError('IPv6 "delegate" also requires "prefix" to be defined!')

	for delegate in ipv6_pool['delegate']:
	if 'delegation_prefix' not in ipv6_pool['delegate'][delegate]:
	raise ConfigError('delegation-prefix length required!')

	def verify_diffie_hellman_length(file, min_keysize):
	""" Verify Diffie-Hellamn keypair length given via file. It must be greater
	then or equal to min_keysize """

	try:
	keysize = str(min_keysize)
	except:
	return False

	import os
	import re
	from vyos.util import cmd

	if os.path.exists(file):

	out = cmd(f'openssl dhparam -inform PEM -in {file} -text')
	prog = re.compile('\d+\s+bit')
	if prog.search(out):
	bits = prog.search(out)[0].split()[0]
	if int(bits) >= int(min_keysize):
	return True

	return False

	def verify_route_maps(config):
	"""
	Common helper function used by routing protocol implementations to perform
	recurring validation if the specified route-map for either zebra to kernel
	installation exists (this is the top-level route_map key) or when a route
	is redistributed with a route-map that it exists!
	"""
	if 'route_map' in config:
	route_map = config['route_map']
	# Check if the specified route-map exists, if not error out
	if dict_search(f'policy.route_map.{route_map}', config) == None:
	raise ConfigError(f'Specified route-map "{route_map}" does not exist!')

	if 'redistribute' in config:
	for protocol, protocol_config in config['redistribute'].items():
	if 'route_map' in protocol_config:
	- route_map = protocol_config['route_map']
	+ # A hyphen in a route-map name will be converted to _, take care
	+ # about this effect during validation
	+ route_map = protocol_config['route_map'].replace('-','_')
	# Check if the specified route-map exists, if not error out
	if dict_search(f'policy.route_map.{route_map}', config) == None:
	raise ConfigError(f'Redistribution route-map "{route_map}" ' \
	f'for "{protocol}" does not exist!')
	diff --git a/smoketest/scripts/cli/test_protocols_ospf.py b/smoketest/scripts/cli/test_protocols_ospf.py
	index d78528365..d47838d8c 100755
	--- a/smoketest/scripts/cli/test_protocols_ospf.py
	+++ b/smoketest/scripts/cli/test_protocols_ospf.py
	@@ -1,277 +1,277 @@
	#!/usr/bin/env python3
	#
	# Copyright (C) 2021 VyOS maintainers and contributors
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License version 2 or later as
	# published by the Free Software Foundation.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	import os
	import unittest

	from vyos.configsession import ConfigSession
	from vyos.ifconfig import Section
	from vyos.util import cmd
	from vyos.util import process_named_running

	PROCESS_NAME = 'ospfd'
	base_path = ['protocols', 'ospf']

	-route_map = 'foobarbaz'
	-route_map_seq = '10'
	+route_map = 'foo-bar-baz10'

	def getFRROSPFconfig():
	return cmd('vtysh -c "show run" \| sed -n "/router ospf/,/^!/p"')

	class TestProtocolsOSPF(unittest.TestCase):
	def setUp(self):
	self.session = ConfigSession(os.getpid())
	- self.session.set(['policy', 'route-map', route_map, 'rule', route_map_seq, 'action', 'permit'])
	+ self.session.set(['policy', 'route-map', route_map, 'rule', '10', 'action', 'permit'])
	+ self.session.set(['policy', 'route-map', route_map, 'rule', '20', 'action', 'permit'])

	def tearDown(self):
	# Check for running process
	self.assertTrue(process_named_running(PROCESS_NAME))

	self.session.delete(['policy', 'route-map', route_map])
	self.session.delete(base_path)
	self.session.commit()
	del self.session

	def test_ospf_01_defaults(self):
	# commit changes
	self.session.set(base_path)
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' auto-cost reference-bandwidth 100', frrconfig)
	self.assertIn(f' timers throttle spf 200 1000 10000', frrconfig) # defaults


	def test_ospf_02_simple(self):
	router_id = '127.0.0.1'
	abr_type = 'ibm'
	bandwidth = '1000'
	metric = '123'

	self.session.set(base_path + ['auto-cost', 'reference-bandwidth', bandwidth])
	self.session.set(base_path + ['parameters', 'router-id', router_id])
	self.session.set(base_path + ['parameters', 'abr-type', abr_type])
	self.session.set(base_path + ['log-adjacency-changes', 'detail'])
	self.session.set(base_path + ['default-metric', metric])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' auto-cost reference-bandwidth {bandwidth}', frrconfig)
	self.assertIn(f' ospf router-id {router_id}', frrconfig)
	self.assertIn(f' ospf abr-type {abr_type}', frrconfig)
	self.assertIn(f' timers throttle spf 200 1000 10000', frrconfig) # defaults
	self.assertIn(f' default-metric {metric}', frrconfig)


	def test_ospf_03_access_list(self):
	acl = '100'
	seq = '10'
	protocols = ['bgp', 'connected', 'kernel', 'rip', 'static']

	self.session.set(['policy', 'access-list', acl, 'rule', seq, 'action', 'permit'])
	self.session.set(['policy', 'access-list', acl, 'rule', seq, 'source', 'any'])
	self.session.set(['policy', 'access-list', acl, 'rule', seq, 'destination', 'any'])
	for ptotocol in protocols:
	self.session.set(base_path + ['access-list', acl, 'export', ptotocol])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' timers throttle spf 200 1000 10000', frrconfig) # defaults
	for ptotocol in protocols:
	self.assertIn(f' distribute-list {acl} out {ptotocol}', frrconfig) # defaults
	self.session.delete(['policy', 'access-list', acl])


	def test_ospf_04_default_originate(self):
	seq = '100'
	metric = '50'
	metric_type = '1'

	self.session.set(base_path + ['default-information', 'originate', 'metric', metric])
	self.session.set(base_path + ['default-information', 'originate', 'metric-type', metric_type])
	self.session.set(base_path + ['default-information', 'originate', 'route-map', route_map])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' timers throttle spf 200 1000 10000', frrconfig) # defaults
	self.assertIn(f' default-information originate metric {metric} metric-type {metric_type} route-map {route_map}', frrconfig)

	# Now set 'always'
	self.session.set(base_path + ['default-information', 'originate', 'always'])
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f' default-information originate always metric {metric} metric-type {metric_type} route-map {route_map}', frrconfig)


	def test_ospf_05_options(self):
	global_distance = '128'
	intra_area = '100'
	inter_area = '110'
	external = '120'
	on_startup = '30'
	on_shutdown = '60'
	refresh = '50'

	self.session.set(base_path + ['distance', 'global', global_distance])
	self.session.set(base_path + ['distance', 'ospf', 'external', external])
	self.session.set(base_path + ['distance', 'ospf', 'intra-area', intra_area])

	self.session.set(base_path + ['max-metric', 'router-lsa', 'on-startup', on_startup])
	self.session.set(base_path + ['max-metric', 'router-lsa', 'on-shutdown', on_shutdown])

	self.session.set(base_path + ['mpls-te', 'enable'])
	self.session.set(base_path + ['refresh', 'timers', refresh])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' mpls-te on', frrconfig)
	self.assertIn(f' mpls-te router-address 0.0.0.0', frrconfig) # default
	self.assertIn(f' distance {global_distance}', frrconfig)
	self.assertIn(f' distance ospf intra-area {intra_area} external {external}', frrconfig)
	self.assertIn(f' max-metric router-lsa on-startup {on_startup}', frrconfig)
	self.assertIn(f' max-metric router-lsa on-shutdown {on_shutdown}', frrconfig)
	self.assertIn(f' refresh timer {refresh}', frrconfig)


	# enable inter-area
	self.session.set(base_path + ['distance', 'ospf', 'inter-area', inter_area])
	self.session.commit()

	frrconfig = getFRROSPFconfig()
	self.assertIn(f' distance ospf intra-area {intra_area} inter-area {inter_area} external {external}', frrconfig)


	def test_ospf_06_neighbor(self):
	priority = '10'
	poll_interval = '20'
	neighbors = ['1.1.1.1', '2.2.2.2', '3.3.3.3']
	for neighbor in neighbors:
	self.session.set(base_path + ['neighbor', neighbor, 'priority', priority])
	self.session.set(base_path + ['neighbor', neighbor, 'poll-interval', poll_interval])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	for neighbor in neighbors:
	self.assertIn(f' neighbor {neighbor} priority {priority} poll-interval {poll_interval}', frrconfig) # default


	def test_ospf_07_passive_interface(self):
	self.session.set(base_path + ['passive-interface', 'default'])
	interfaces = Section.interfaces('ethernet')
	for interface in interfaces:
	self.session.set(base_path + ['passive-interface-exclude', interface])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' passive-interface default', frrconfig) # default
	for interface in interfaces:
	self.assertIn(f' no passive-interface {interface}', frrconfig) # default


	def test_ospf_08_redistribute(self):
	metric = '15'
	metric_type = '1'
	redistribute = ['bgp', 'connected', 'kernel', 'rip', 'static']

	for protocol in redistribute:
	self.session.set(base_path + ['redistribute', protocol, 'metric', metric])
	self.session.set(base_path + ['redistribute', protocol, 'route-map', route_map])
	if protocol not in ['kernel', 'static']:
	self.session.set(base_path + ['redistribute', protocol, 'metric-type', metric_type])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	for protocol in redistribute:
	if protocol in ['kernel', 'static']:
	self.assertIn(f' redistribute {protocol} metric {metric} route-map {route_map}', frrconfig)
	else:
	self.assertIn(f' redistribute {protocol} metric {metric} metric-type {metric_type} route-map {route_map}', frrconfig)


	def test_ospf_09_area(self):
	area = '0'
	networks = ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16']
	for network in networks:
	self.session.set(base_path + ['area', area, 'network', network])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	for network in networks:
	self.assertIn(f' network {network} area {area}', frrconfig)


	def test_ospf_10_virtual_link(self):
	area = '10'
	shortcut = 'enable'
	virtual_link = '192.0.2.1'
	hello = '6'
	retransmit = '5'
	transmit = '5'
	dead = '40'

	self.session.set(base_path + ['area', area, 'shortcut', shortcut])
	self.session.set(base_path + ['area', area, 'virtual-link', virtual_link, 'hello-interval', hello])
	self.session.set(base_path + ['area', area, 'virtual-link', virtual_link, 'retransmit-interval', retransmit])
	self.session.set(base_path + ['area', area, 'virtual-link', virtual_link, 'transmit-delay', transmit])
	self.session.set(base_path + ['area', area, 'virtual-link', virtual_link, 'dead-interval', dead])

	# commit changes
	self.session.commit()

	# Verify FRR ospfd configuration
	frrconfig = getFRROSPFconfig()
	self.assertIn(f'router ospf', frrconfig)
	self.assertIn(f' area {area} shortcut {shortcut}', frrconfig)
	self.assertIn(f' area {area} virtual-link {virtual_link} hello-interval {hello} retransmit-interval {retransmit} transmit-delay {transmit} dead-interval {dead}', frrconfig)

	if __name__ == '__main__':
	unittest.main(verbosity=2)
	diff --git a/src/conf_mode/protocols_ospf.py b/src/conf_mode/protocols_ospf.py
	index 9842d26cd..7c0ffbd27 100755
	--- a/src/conf_mode/protocols_ospf.py
	+++ b/src/conf_mode/protocols_ospf.py
	@@ -1,156 +1,163 @@
	#!/usr/bin/env python3
	#
	# Copyright (C) 2021 VyOS maintainers and contributors
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License version 2 or later as
	# published by the Free Software Foundation.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	import os

	from sys import exit

	from vyos.config import Config
	from vyos.configdict import dict_merge
	from vyos.configverify import verify_route_maps
	from vyos.template import render
	from vyos.template import render_to_string
	from vyos.util import call
	from vyos.util import dict_search
	from vyos.xml import defaults
	from vyos import ConfigError
	from vyos import frr
	from vyos import airbag
	airbag.enable()

	config_file = r'/tmp/ospf.frr'
	frr_daemon = 'ospfd'

	DEBUG = os.path.exists('/tmp/ospf.debug')
	if DEBUG:
	import logging
	lg = logging.getLogger("vyos.frr")
	lg.setLevel(logging.DEBUG)
	ch = logging.StreamHandler()
	lg.addHandler(ch)

	def get_config(config=None):
	if config:
	conf = config
	else:
	conf = Config()
	base = ['protocols', 'ospf']
	ospf = conf.get_config_dict(base, key_mangling=('-', '_'), get_first_key=True)

	# Bail out early if configuration tree does not exist
	if not conf.exists(base):
	return ospf

	# We have gathered the dict representation of the CLI, but there are default
	# options which we need to update into the dictionary retrived.
	default_values = defaults(base)

	# We have to cleanup the default dict, as default values could enable features
	# which are not explicitly enabled on the CLI. Example: default-information
	# originate comes with a default metric-type of 2, which will enable the
	# entire default-information originate tree, even when not set via CLI so we
	# need to check this first and probably drop that key.
	if dict_search('default_information.originate', ospf) is None:
	del default_values['default_information']
	if dict_search('area.area_type.nssa', ospf) is None:
	del default_values['area']['area_type']['nssa']
	if 'mpls_te' not in ospf:
	del default_values['mpls_te']
	for protocol in ['bgp', 'connected', 'kernel', 'rip', 'static']:
	if dict_search(f'redistribute.{protocol}', ospf) is None:
	del default_values['redistribute'][protocol]
	# XXX: T2665: we currently have no nice way for defaults under tag nodes,
	# clean them out and add them manually :(
	del default_values['neighbor']
	del default_values['area']['virtual_link']

	# merge in remaining default values
	ospf = dict_merge(default_values, ospf)

	if 'neighbor' in ospf:
	default_values = defaults(base + ['neighbor'])
	for neighbor in ospf['neighbor']:
	ospf['neighbor'][neighbor] = dict_merge(default_values, ospf['neighbor'][neighbor])

	if 'area' in ospf:
	default_values = defaults(base + ['area', 'virtual-link'])
	for area, area_config in ospf['area'].items():
	if 'virtual_link' in area_config:
	print(default_values)
	for virtual_link in area_config['virtual_link']:
	ospf['area'][area]['virtual_link'][virtual_link] = dict_merge(
	default_values, ospf['area'][area]['virtual_link'][virtual_link])

	+ # We also need some additional information from the config, prefix-lists
	+ # and route-maps for instance. They will be used in verify()
	+ base = ['policy']
	+ tmp = conf.get_config_dict(base, key_mangling=('-', '_'))
	+ # Merge policy dict into OSPF dict
	+ ospf = dict_merge(tmp, ospf)
	+
	return ospf

	def verify(ospf):
	if not ospf:
	return None

	verify_route_maps(ospf)
	return None

	def generate(ospf):
	if not ospf:
	ospf['new_frr_config'] = ''
	return None

	# render(config) not needed, its only for debug
	render(config_file, 'frr/ospf.frr.tmpl', ospf)
	ospf['new_frr_config'] = render_to_string('frr/ospf.frr.tmpl', ospf)

	return None

	def apply(ospf):
	# Save original configuration prior to starting any commit actions
	frr_cfg = frr.FRRConfig()
	frr_cfg.load_configuration(frr_daemon)
	frr_cfg.modify_section('router ospf', '')
	frr_cfg.add_before(r'(ip prefix-list .\|route-map .\|line vty)', ospf['new_frr_config'])

	# Debugging
	if DEBUG:
	from pprint import pprint
	print('')
	print('--------- DEBUGGING ----------')
	pprint(dir(frr_cfg))
	print('Existing config:\n')
	for line in frr_cfg.original_config:
	print(line)
	print(f'Replacement config:\n')
	print(f'{ospf["new_frr_config"]}')
	print(f'Modified config:\n')
	print(f'{frr_cfg}')

	frr_cfg.commit_configuration(frr_daemon)

	# If FRR config is blank, rerun the blank commit x times due to frr-reload
	# behavior/bug not properly clearing out on one commit.
	if ospf['new_frr_config'] == '':
	for a in range(5):
	frr_cfg.commit_configuration(frr_daemon)

	return None

	if __name__ == '__main__':
	try:
	c = get_config()
	verify(c)
	generate(c)
	apply(c)
	except ConfigError as e:
	print(e)
	exit(1)

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 17, 12:23 AM (4 h, 26 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4416562
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions