No OneTemporary
Actions

Size

34 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/smoketest/scripts/cli/test_protocols_isis.py b/smoketest/scripts/cli/test_protocols_isis.py
	index aa5f2f38c..0fd18a6da 100755
	--- a/smoketest/scripts/cli/test_protocols_isis.py
	+++ b/smoketest/scripts/cli/test_protocols_isis.py
	@@ -1,393 +1,399 @@
	#!/usr/bin/env python3
	#
	-# Copyright (C) 2021-2023 VyOS maintainers and contributors
	+# Copyright (C) 2021-2024 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 unittest

	from base_vyostest_shim import VyOSUnitTestSHIM
	from vyos.configsession import ConfigSessionError
	from vyos.ifconfig import Section
	from vyos.utils.process import process_named_running

	PROCESS_NAME = 'isisd'
	base_path = ['protocols', 'isis']

	domain = 'VyOS'
	net = '49.0001.1921.6800.1002.00'

	class TestProtocolsISIS(VyOSUnitTestSHIM.TestCase):
	@classmethod
	def setUpClass(cls):
	cls._interfaces = Section.interfaces('ethernet')
	# call base-classes classmethod
	super(TestProtocolsISIS, cls).setUpClass()
	# Retrieve FRR daemon PID - it is not allowed to crash, thus PID must remain the same
	cls.daemon_pid = process_named_running(PROCESS_NAME)
	# ensure we can also run this test on a live system - so lets clean
	# out the current configuration :)
	cls.cli_delete(cls, base_path)
	cls.cli_delete(cls, ['vrf'])

	def tearDown(self):
	# cleanup any possible VRF mess
	self.cli_delete(['vrf'])
	# always destrox the entire isisd configuration to make the processes
	# life as hard as possible
	self.cli_delete(base_path)
	self.cli_commit()

	# check process health and continuity
	self.assertEqual(self.daemon_pid, process_named_running(PROCESS_NAME))

	def isis_base_config(self):
	self.cli_set(base_path + ['net', net])
	for interface in self._interfaces:
	self.cli_set(base_path + ['interface', interface])

	def test_isis_01_redistribute(self):
	prefix_list = 'EXPORT-ISIS'
	route_map = 'EXPORT-ISIS'
	rule = '10'

	self.cli_set(['policy', 'prefix-list', prefix_list, 'rule', rule, 'action', 'permit'])
	self.cli_set(['policy', 'prefix-list', prefix_list, 'rule', rule, 'prefix', '203.0.113.0/24'])
	self.cli_set(['policy', 'route-map', route_map, 'rule', rule, 'action', 'permit'])
	self.cli_set(['policy', 'route-map', route_map, 'rule', rule, 'match', 'ip', 'address', 'prefix-list', prefix_list])

	self.cli_set(base_path)

	# verify() - net id and interface are mandatory
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()

	self.isis_base_config()
	+
	+ self.cli_set(base_path + ['redistribute', 'ipv4', 'connected'])
	+ # verify() - Redistribute level-1 or level-2 should be specified
	+ with self.assertRaises(ConfigSessionError):
	+ self.cli_commit()
	+
	self.cli_set(base_path + ['redistribute', 'ipv4', 'connected', 'level-2', 'route-map', route_map])
	self.cli_set(base_path + ['log-adjacency-changes'])

	# Commit all changes
	self.cli_commit()

	# Verify all changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' log-adjacency-changes', tmp)
	self.assertIn(f' redistribute ipv4 connected level-2 route-map {route_map}', tmp)

	for interface in self._interfaces:
	tmp = self.getFRRconfig(f'interface {interface}', daemon='isisd')
	self.assertIn(f' ip router isis {domain}', tmp)
	self.assertIn(f' ipv6 router isis {domain}', tmp)

	self.cli_delete(['policy', 'route-map', route_map])
	self.cli_delete(['policy', 'prefix-list', prefix_list])

	def test_isis_02_vrfs(self):
	vrfs = ['red', 'green', 'blue']
	# It is safe to assume that when the basic VRF test works, all other
	# IS-IS related features work, as we entirely inherit the CLI templates
	# and Jinja2 FRR template.
	table = '1000'
	vrf = 'red'
	vrf_base = ['vrf', 'name', vrf]
	vrf_iface = 'eth1'
	self.cli_set(vrf_base + ['table', table])
	self.cli_set(vrf_base + ['protocols', 'isis', 'net', net])
	self.cli_set(vrf_base + ['protocols', 'isis', 'interface', vrf_iface])
	self.cli_set(vrf_base + ['protocols', 'isis', 'advertise-high-metrics'])
	self.cli_set(vrf_base + ['protocols', 'isis', 'advertise-passive-only'])
	self.cli_set(['interfaces', 'ethernet', vrf_iface, 'vrf', vrf])

	# Also set a default VRF IS-IS config
	self.cli_set(base_path + ['net', net])
	self.cli_set(base_path + ['interface', 'eth0'])
	self.cli_commit()

	# Verify FRR isisd configuration
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f'router isis {domain}', tmp)
	self.assertIn(f' net {net}', tmp)

	tmp = self.getFRRconfig(f'router isis {domain} vrf {vrf}', daemon='isisd')
	self.assertIn(f'router isis {domain} vrf {vrf}', tmp)
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' advertise-high-metrics', tmp)
	self.assertIn(f' advertise-passive-only', tmp)

	self.cli_delete(['vrf', 'name', vrf])
	self.cli_delete(['interfaces', 'ethernet', vrf_iface, 'vrf'])

	def test_isis_04_default_information(self):
	metric = '50'
	route_map = 'default-foo-'

	self.isis_base_config()
	for afi in ['ipv4', 'ipv6']:
	for level in ['level-1', 'level-2']:
	self.cli_set(base_path + ['default-information', 'originate', afi, level, 'always'])
	self.cli_set(base_path + ['default-information', 'originate', afi, level, 'metric', metric])
	self.cli_set(base_path + ['default-information', 'originate', afi, level, 'route-map', route_map + level + afi])

	# Commit all changes
	self.cli_commit()

	# Verify all changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)

	for afi in ['ipv4', 'ipv6']:
	for level in ['level-1', 'level-2']:
	route_map_name = route_map + level + afi
	self.assertIn(f' default-information originate {afi} {level} always route-map {route_map_name} metric {metric}', tmp)


	def test_isis_05_password(self):
	password = 'foo'

	self.isis_base_config()
	for interface in self._interfaces:
	self.cli_set(base_path + ['interface', interface, 'password', 'plaintext-password', f'{password}-{interface}'])

	self.cli_set(base_path + ['area-password', 'plaintext-password', password])
	self.cli_set(base_path + ['area-password', 'md5', password])
	self.cli_set(base_path + ['domain-password', 'plaintext-password', password])
	self.cli_set(base_path + ['domain-password', 'md5', password])

	# verify() - can not use both md5 and plaintext-password for area-password
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_delete(base_path + ['area-password', 'md5', password])

	# verify() - can not use both md5 and plaintext-password for domain-password
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_delete(base_path + ['domain-password', 'md5', password])

	# Commit all changes
	self.cli_commit()

	# Verify all changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' domain-password clear {password}', tmp)
	self.assertIn(f' area-password clear {password}', tmp)

	for interface in self._interfaces:
	tmp = self.getFRRconfig(f'interface {interface}', daemon='isisd')
	self.assertIn(f' isis password clear {password}-{interface}', tmp)

	def test_isis_06_spf_delay_bfd(self):
	network = 'point-to-point'
	holddown = '10'
	init_delay = '50'
	long_delay = '200'
	short_delay = '100'
	time_to_learn = '75'
	bfd_profile = 'isis-bfd'

	self.cli_set(base_path + ['net', net])
	for interface in self._interfaces:
	self.cli_set(base_path + ['interface', interface, 'network', network])
	self.cli_set(base_path + ['interface', interface, 'bfd', 'profile', bfd_profile])

	self.cli_set(base_path + ['spf-delay-ietf', 'holddown', holddown])
	# verify() - All types of spf-delay must be configured
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()

	self.cli_set(base_path + ['spf-delay-ietf', 'init-delay', init_delay])
	# verify() - All types of spf-delay must be configured
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()

	self.cli_set(base_path + ['spf-delay-ietf', 'long-delay', long_delay])
	# verify() - All types of spf-delay must be configured
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()

	self.cli_set(base_path + ['spf-delay-ietf', 'short-delay', short_delay])
	# verify() - All types of spf-delay must be configured
	with self.assertRaises(ConfigSessionError):
	self.cli_commit()
	self.cli_set(base_path + ['spf-delay-ietf', 'time-to-learn', time_to_learn])

	# Commit all changes
	self.cli_commit()

	# Verify all changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' spf-delay-ietf init-delay {init_delay} short-delay {short_delay} long-delay {long_delay} holddown {holddown} time-to-learn {time_to_learn}', tmp)

	for interface in self._interfaces:
	tmp = self.getFRRconfig(f'interface {interface}', daemon='isisd')
	self.assertIn(f' ip router isis {domain}', tmp)
	self.assertIn(f' ipv6 router isis {domain}', tmp)
	self.assertIn(f' isis network {network}', tmp)
	self.assertIn(f' isis bfd', tmp)
	self.assertIn(f' isis bfd profile {bfd_profile}', tmp)

	def test_isis_07_segment_routing_configuration(self):
	global_block_low = "300"
	global_block_high = "399"
	local_block_low = "400"
	local_block_high = "499"
	interface = 'lo'
	maximum_stack_size = '5'
	prefix_one = '192.168.0.1/32'
	prefix_two = '192.168.0.2/32'
	prefix_three = '192.168.0.3/32'
	prefix_four = '192.168.0.4/32'
	prefix_one_value = '1'
	prefix_two_value = '2'
	prefix_three_value = '60000'
	prefix_four_value = '65000'

	self.cli_set(base_path + ['net', net])
	self.cli_set(base_path + ['interface', interface])
	self.cli_set(base_path + ['segment-routing', 'maximum-label-depth', maximum_stack_size])
	self.cli_set(base_path + ['segment-routing', 'global-block', 'low-label-value', global_block_low])
	self.cli_set(base_path + ['segment-routing', 'global-block', 'high-label-value', global_block_high])
	self.cli_set(base_path + ['segment-routing', 'local-block', 'low-label-value', local_block_low])
	self.cli_set(base_path + ['segment-routing', 'local-block', 'high-label-value', local_block_high])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_one, 'index', 'value', prefix_one_value])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_one, 'index', 'explicit-null'])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_two, 'index', 'value', prefix_two_value])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_two, 'index', 'no-php-flag'])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_three, 'absolute', 'value', prefix_three_value])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_three, 'absolute', 'explicit-null'])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_four, 'absolute', 'value', prefix_four_value])
	self.cli_set(base_path + ['segment-routing', 'prefix', prefix_four, 'absolute', 'no-php-flag'])

	# Commit all changes
	self.cli_commit()

	# Verify all changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' segment-routing on', tmp)
	self.assertIn(f' segment-routing global-block {global_block_low} {global_block_high} local-block {local_block_low} {local_block_high}', tmp)
	self.assertIn(f' segment-routing node-msd {maximum_stack_size}', tmp)
	self.assertIn(f' segment-routing prefix {prefix_one} index {prefix_one_value} explicit-null', tmp)
	self.assertIn(f' segment-routing prefix {prefix_two} index {prefix_two_value} no-php-flag', tmp)
	self.assertIn(f' segment-routing prefix {prefix_three} absolute {prefix_three_value} explicit-null', tmp)
	self.assertIn(f' segment-routing prefix {prefix_four} absolute {prefix_four_value} no-php-flag', tmp)

	def test_isis_08_ldp_sync(self):
	holddown = "500"
	interface = 'lo'

	self.cli_set(base_path + ['net', net])
	self.cli_set(base_path + ['interface', interface])
	self.cli_set(base_path + ['ldp-sync', 'holddown', holddown])

	# Commit main ISIS changes
	self.cli_commit()

	# Verify main ISIS changes
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' mpls ldp-sync', tmp)
	self.assertIn(f' mpls ldp-sync holddown {holddown}', tmp)

	for interface in self._interfaces:
	self.cli_set(base_path + ['interface', interface, 'ldp-sync', 'holddown', holddown])

	# Commit interface changes for holddown
	self.cli_commit()

	for interface in self._interfaces:
	# Verify interface changes for holddown
	tmp = self.getFRRconfig(f'interface {interface}', daemon='isisd')
	self.assertIn(f'interface {interface}', tmp)
	self.assertIn(f' ip router isis {domain}', tmp)
	self.assertIn(f' ipv6 router isis {domain}', tmp)
	self.assertIn(f' isis mpls ldp-sync holddown {holddown}', tmp)

	for interface in self._interfaces:
	self.cli_set(base_path + ['interface', interface, 'ldp-sync', 'disable'])

	# Commit interface changes for disable
	self.cli_commit()

	for interface in self._interfaces:
	# Verify interface changes for disable
	tmp = self.getFRRconfig(f'interface {interface}', daemon='isisd')
	self.assertIn(f'interface {interface}', tmp)
	self.assertIn(f' ip router isis {domain}', tmp)
	self.assertIn(f' ipv6 router isis {domain}', tmp)
	self.assertIn(f' no isis mpls ldp-sync', tmp)

	def test_isis_09_lfa(self):
	prefix_list = 'lfa-prefix-list-test-1'
	prefix_list_address = '192.168.255.255/32'
	interface = 'lo'

	self.cli_set(base_path + ['net', net])
	self.cli_set(base_path + ['interface', interface])
	self.cli_set(['policy', 'prefix-list', prefix_list, 'rule', '1', 'action', 'permit'])
	self.cli_set(['policy', 'prefix-list', prefix_list, 'rule', '1', 'prefix', prefix_list_address])

	# Commit main ISIS changes
	self.cli_commit()

	# Add remote portion of LFA with prefix list with validation
	for level in ['level-1', 'level-2']:
	self.cli_set(base_path + ['fast-reroute', 'lfa', 'remote', 'prefix-list', prefix_list, level])
	self.cli_commit()
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' fast-reroute remote-lfa prefix-list {prefix_list} {level}', tmp)
	self.cli_delete(base_path + ['fast-reroute'])
	self.cli_commit()

	# Add local portion of LFA load-sharing portion with validation
	for level in ['level-1', 'level-2']:
	self.cli_set(base_path + ['fast-reroute', 'lfa', 'local', 'load-sharing', 'disable', level])
	self.cli_commit()
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' fast-reroute load-sharing disable {level}', tmp)
	self.cli_delete(base_path + ['fast-reroute'])
	self.cli_commit()

	# Add local portion of LFA priority-limit portion with validation
	for priority in ['critical', 'high', 'medium']:
	for level in ['level-1', 'level-2']:
	self.cli_set(base_path + ['fast-reroute', 'lfa', 'local', 'priority-limit', priority, level])
	self.cli_commit()
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' fast-reroute priority-limit {priority} {level}', tmp)
	self.cli_delete(base_path + ['fast-reroute'])
	self.cli_commit()

	# Add local portion of LFA tiebreaker portion with validation
	index = '100'
	for tiebreaker in ['downstream','lowest-backup-metric','node-protecting']:
	for level in ['level-1', 'level-2']:
	self.cli_set(base_path + ['fast-reroute', 'lfa', 'local', 'tiebreaker', tiebreaker, 'index', index, level])
	self.cli_commit()
	tmp = self.getFRRconfig(f'router isis {domain}', daemon='isisd')
	self.assertIn(f' net {net}', tmp)
	self.assertIn(f' fast-reroute lfa tiebreaker {tiebreaker} index {index} {level}', tmp)
	self.cli_delete(base_path + ['fast-reroute'])
	self.cli_commit()

	# Clean up and remove prefix list
	self.cli_delete(['policy', 'prefix-list', prefix_list])
	self.cli_commit()

	if __name__ == '__main__':
	unittest.main(verbosity=2)
	diff --git a/src/conf_mode/protocols_isis.py b/src/conf_mode/protocols_isis.py
	index 8d594bb68..6c9925b80 100755
	--- a/src/conf_mode/protocols_isis.py
	+++ b/src/conf_mode/protocols_isis.py
	@@ -1,314 +1,314 @@
	#!/usr/bin/env python3
	#
	-# Copyright (C) 2020-2022 VyOS maintainers and contributors
	+# Copyright (C) 2020-2024 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 sys import argv

	from vyos.config import Config
	from vyos.configdict import dict_merge
	from vyos.configdict import node_changed
	from vyos.configverify import verify_common_route_maps
	from vyos.configverify import verify_interface_exists
	from vyos.ifconfig import Interface
	from vyos.utils.dict import dict_search
	from vyos.utils.network import get_interface_config
	from vyos.template import render_to_string
	from vyos import ConfigError
	from vyos import frr
	from vyos import airbag
	airbag.enable()

	def get_config(config=None):
	if config:
	conf = config
	else:
	conf = Config()

	vrf = None
	if len(argv) > 1:
	vrf = argv[1]

	base_path = ['protocols', 'isis']

	# eqivalent of the C foo ? 'a' : 'b' statement
	base = vrf and ['vrf', 'name', vrf, 'protocols', 'isis'] or base_path
	isis = conf.get_config_dict(base, key_mangling=('-', '_'),
	get_first_key=True,
	no_tag_node_value_mangle=True)

	# Assign the name of our VRF context. This MUST be done before the return
	# statement below, else on deletion we will delete the default instance
	# instead of the VRF instance.
	if vrf: isis['vrf'] = vrf

	# FRR has VRF support for different routing daemons. As interfaces belong
	# to VRFs - or the global VRF, we need to check for changed interfaces so
	# that they will be properly rendered for the FRR config. Also this eases
	# removal of interfaces from the running configuration.
	interfaces_removed = node_changed(conf, base + ['interface'])
	if interfaces_removed:
	isis['interface_removed'] = list(interfaces_removed)

	# Bail out early if configuration tree does no longer exist. this must
	# be done after retrieving the list of interfaces to be removed.
	if not conf.exists(base):
	isis.update({'deleted' : ''})
	return isis

	# merge in default values
	isis = conf.merge_defaults(isis, recursive=True)

	# We also need some additional information from the config, prefix-lists
	# and route-maps for instance. They will be used in verify().
	#
	# XXX: one MUST always call this without the key_mangling() option! See
	# vyos.configverify.verify_common_route_maps() for more information.
	tmp = conf.get_config_dict(['policy'])
	# Merge policy dict into "regular" config dict
	isis = dict_merge(tmp, isis)

	return isis

	def verify(isis):
	# bail out early - looks like removal from running config
	if not isis or 'deleted' in isis:
	return None

	if 'net' not in isis:
	raise ConfigError('Network entity is mandatory!')

	# last byte in IS-IS area address must be 0
	tmp = isis['net'].split('.')
	if int(tmp[-1]) != 0:
	raise ConfigError('Last byte of IS-IS network entity title must always be 0!')

	verify_common_route_maps(isis)

	# If interface not set
	if 'interface' not in isis:
	raise ConfigError('Interface used for routing updates is mandatory!')

	for interface in isis['interface']:
	verify_interface_exists(interface)
	# Interface MTU must be >= configured lsp-mtu
	mtu = Interface(interface).get_mtu()
	area_mtu = isis['lsp_mtu']
	# Recommended maximum PDU size = interface MTU - 3 bytes
	recom_area_mtu = mtu - 3
	if mtu < int(area_mtu) or int(area_mtu) > recom_area_mtu:
	raise ConfigError(f'Interface {interface} has MTU {mtu}, ' \
	f'current area MTU is {area_mtu}! \n' \
	f'Recommended area lsp-mtu {recom_area_mtu} or less ' \
	'(calculated on MTU size).')

	if 'vrf' in isis:
	# If interface specific options are set, we must ensure that the
	# interface is bound to our requesting VRF. Due to the VyOS
	# priorities the interface is bound to the VRF after creation of
	# the VRF itself, and before any routing protocol is configured.
	vrf = isis['vrf']
	tmp = get_interface_config(interface)
	if 'master' not in tmp or tmp['master'] != vrf:
	raise ConfigError(f'Interface "{interface}" is not a member of VRF "{vrf}"!')

	# If md5 and plaintext-password set at the same time
	for password in ['area_password', 'domain_password']:
	if password in isis:
	if {'md5', 'plaintext_password'} <= set(isis[password]):
	tmp = password.replace('_', '-')
	raise ConfigError(f'Can use either md5 or plaintext-password for {tmp}!')

	# If one param from delay set, but not set others
	if 'spf_delay_ietf' in isis:
	required_timers = ['holddown', 'init_delay', 'long_delay', 'short_delay', 'time_to_learn']
	exist_timers = []
	for elm_timer in required_timers:
	if elm_timer in isis['spf_delay_ietf']:
	exist_timers.append(elm_timer)

	exist_timers = set(required_timers).difference(set(exist_timers))
	if len(exist_timers) > 0:
	raise ConfigError('All types of spf-delay must be configured. Missing: ' + ', '.join(exist_timers).replace('_', '-'))

	# If Redistribute set, but level don't set
	if 'redistribute' in isis:
	proc_level = isis.get('level','').replace('-','_')
	for afi in ['ipv4', 'ipv6']:
	if afi not in isis['redistribute']:
	continue

	for proto, proto_config in isis['redistribute'][afi].items():
	if 'level_1' not in proto_config and 'level_2' not in proto_config:
	raise ConfigError(f'Redistribute level-1 or level-2 should be specified in ' \
	- f'"protocols isis {process} redistribute {afi} {proto}"!')
	+ f'"protocols isis redistribute {afi} {proto}"!')

	for redistr_level, redistr_config in proto_config.items():
	if proc_level and proc_level != 'level_1_2' and proc_level != redistr_level:
	- raise ConfigError(f'"protocols isis {process} redistribute {afi} {proto} {redistr_level}" ' \
	- f'can not be used with \"protocols isis {process} level {proc_level}\"')
	+ raise ConfigError(f'"protocols isis redistribute {afi} {proto} {redistr_level}" ' \
	+ f'can not be used with \"protocols isis level {proc_level}\"!')

	# Segment routing checks
	if dict_search('segment_routing.global_block', isis):
	g_high_label_value = dict_search('segment_routing.global_block.high_label_value', isis)
	g_low_label_value = dict_search('segment_routing.global_block.low_label_value', isis)

	# If segment routing global block high or low value is blank, throw error
	if not (g_low_label_value or g_high_label_value):
	raise ConfigError('Segment routing global-block requires both low and high value!')

	# If segment routing global block low value is higher than the high value, throw error
	if int(g_low_label_value) > int(g_high_label_value):
	raise ConfigError('Segment routing global-block low value must be lower than high value')

	if dict_search('segment_routing.local_block', isis):
	if dict_search('segment_routing.global_block', isis) == None:
	raise ConfigError('Segment routing local-block requires global-block to be configured!')

	l_high_label_value = dict_search('segment_routing.local_block.high_label_value', isis)
	l_low_label_value = dict_search('segment_routing.local_block.low_label_value', isis)

	# If segment routing local-block high or low value is blank, throw error
	if not (l_low_label_value or l_high_label_value):
	raise ConfigError('Segment routing local-block requires both high and low value!')

	# If segment routing local-block low value is higher than the high value, throw error
	if int(l_low_label_value) > int(l_high_label_value):
	raise ConfigError('Segment routing local-block low value must be lower than high value')

	# local-block most live outside global block
	global_range = range(int(g_low_label_value), int(g_high_label_value) +1)
	local_range = range(int(l_low_label_value), int(l_high_label_value) +1)

	# Check for overlapping ranges
	if list(set(global_range) & set(local_range)):
	raise ConfigError(f'Segment-Routing Global Block ({g_low_label_value}/{g_high_label_value}) '\
	f'conflicts with Local Block ({l_low_label_value}/{l_high_label_value})!')

	# Check for a blank or invalid value per prefix
	if dict_search('segment_routing.prefix', isis):
	for prefix, prefix_config in isis['segment_routing']['prefix'].items():
	if 'absolute' in prefix_config:
	if prefix_config['absolute'].get('value') is None:
	raise ConfigError(f'Segment routing prefix {prefix} absolute value cannot be blank.')
	elif 'index' in prefix_config:
	if prefix_config['index'].get('value') is None:
	raise ConfigError(f'Segment routing prefix {prefix} index value cannot be blank.')

	# Check for explicit-null and no-php-flag configured at the same time per prefix
	if dict_search('segment_routing.prefix', isis):
	for prefix, prefix_config in isis['segment_routing']['prefix'].items():
	if 'absolute' in prefix_config:
	if ("explicit_null" in prefix_config['absolute']) and ("no_php_flag" in prefix_config['absolute']):
	raise ConfigError(f'Segment routing prefix {prefix} cannot have both explicit-null '\
	f'and no-php-flag configured at the same time.')
	elif 'index' in prefix_config:
	if ("explicit_null" in prefix_config['index']) and ("no_php_flag" in prefix_config['index']):
	raise ConfigError(f'Segment routing prefix {prefix} cannot have both explicit-null '\
	f'and no-php-flag configured at the same time.')
	-
	- # Check for index ranges being larger than the segment routing global block
	+
	+ # Check for index ranges being larger than the segment routing global block
	if dict_search('segment_routing.global_block', isis):
	g_high_label_value = dict_search('segment_routing.global_block.high_label_value', isis)
	g_low_label_value = dict_search('segment_routing.global_block.low_label_value', isis)
	g_label_difference = int(g_high_label_value) - int(g_low_label_value)
	if dict_search('segment_routing.prefix', isis):
	for prefix, prefix_config in isis['segment_routing']['prefix'].items():
	if 'index' in prefix_config:
	index_size = isis['segment_routing']['prefix'][prefix]['index']['value']
	if int(index_size) > int(g_label_difference):
	raise ConfigError(f'Segment routing prefix {prefix} cannot have an '\
	f'index base size larger than the SRGB label base.')
	-
	+
	# Check for LFA tiebreaker index duplication
	if dict_search('fast_reroute.lfa.local.tiebreaker', isis):
	comparison_dictionary = {}
	for item, item_options in isis['fast_reroute']['lfa']['local']['tiebreaker'].items():
	for index, index_options in item_options.items():
	for index_value, index_value_options in index_options.items():
	if index_value not in comparison_dictionary.keys():
	comparison_dictionary[index_value] = [item]
	else:
	comparison_dictionary[index_value].append(item)
	for index, index_length in comparison_dictionary.items():
	if int(len(index_length)) > 1:
	raise ConfigError(f'LFA index {index} cannot have more than one tiebreaker configured.')

	# Check for LFA priority-limit configured multiple times per level
	if dict_search('fast_reroute.lfa.local.priority_limit', isis):
	comparison_dictionary = {}
	for priority, priority_options in isis['fast_reroute']['lfa']['local']['priority_limit'].items():
	for level, level_options in priority_options.items():
	if level not in comparison_dictionary.keys():
	comparison_dictionary[level] = [priority]
	else:
	comparison_dictionary[level].append(priority)
	for level, level_length in comparison_dictionary.items():
	if int(len(level_length)) > 1:
	raise ConfigError(f'LFA priority-limit on {level.replace("_", "-")} cannot have more than one priority configured.')

	# Check for LFA remote prefix list configured with more than one list
	if dict_search('fast_reroute.lfa.remote.prefix_list', isis):
	if int(len(isis['fast_reroute']['lfa']['remote']['prefix_list'].items())) > 1:
	raise ConfigError(f'LFA remote prefix-list has more than one configured. Cannot have more than one configured.')

	return None

	def generate(isis):
	if not isis or 'deleted' in isis:
	return None

	isis['frr_isisd_config'] = render_to_string('frr/isisd.frr.j2', isis)
	return None

	def apply(isis):
	isis_daemon = 'isisd'

	# Save original configuration prior to starting any commit actions
	frr_cfg = frr.FRRConfig()

	# Generate empty helper string which can be ammended to FRR commands, it
	# will be either empty (default VRF) or contain the "vrf <name" statement
	vrf = ''
	if 'vrf' in isis:
	vrf = ' vrf ' + isis['vrf']

	frr_cfg.load_configuration(isis_daemon)
	frr_cfg.modify_section(f'^router isis VyOS{vrf}', stop_pattern='^exit', remove_stop_mark=True)

	for key in ['interface', 'interface_removed']:
	if key not in isis:
	continue
	for interface in isis[key]:
	frr_cfg.modify_section(f'^interface {interface}', stop_pattern='^exit', remove_stop_mark=True)

	if 'frr_isisd_config' in isis:
	frr_cfg.add_before(frr.default_add_before, isis['frr_isisd_config'])

	frr_cfg.commit_configuration(isis_daemon)

	return None

	if __name__ == '__main__':
	try:
	c = get_config()
	verify(c)
	generate(c)
	apply(c)
	except ConfigError as e:
	print(e)
	- exit(1)
	\ No newline at end of file
	+ exit(1)

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 6, 10:27 AM (59 m, 42 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4654209
Default Alt Text: (34 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions