ip-link service (8a3b7eb8) · Commits · TFS / controller

src/service/service/service_handler_api/SettingsHandler.py

+2 −2

Original line number	Diff line number	Diff line
		@@ -48,8 +48,8 @@ class SettingsHandler:
		key_or_path = ACL_KEY_TEMPLATE.format(device_uuid, endpoint_name,endpoint_index, acl_ruleset_name)
		value = grpc_message_to_json(config_rule.acl)
		elif kind == 'ip_link':
		device_uuid = config_rule.ip_link.device1
		endpoint_uuid = config_rule.ip_link.interface
		device_uuid = config_rule.ip_link.endpoint_id.device_id.device_uuid.uuid
		endpoint_uuid = config_rule.ip_link.endpoint_id.endpoint_uuid.uuid
		IP_LINK_KEY_TEMPLATE = '/device[{:s}]/endpoint[{:s}]/ip_link'
		key_or_path = IP_LINK_KEY_TEMPLATE.format(device_uuid, endpoint_uuid,)
		value = config_rule.ip_link

src/service/service/service_handlers/ip_link/ConfigRules.py

+2 −217

Original line number	Diff line number	Diff line
		@@ -39,167 +39,8 @@ def setup_config_rules(
		settings = (json_settings, json_endpoint_settings, json_device_settings)

		mtu = get_value('mtu', *settings, default=1450) # 1512
		#address_families = json_settings.get('address_families', [] ) # ['IPV4']
		bgp_as = get_value('bgp_as', *settings, default=65000) # 65000

		router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
		route_distinguisher = json_settings.get('route_distinguisher', '65000:101' ) # '60001:801'
		sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
		vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
		address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
		address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30

		policy_import = json_endpoint_settings.get('policy_AZ', '2' ) # 2
		policy_export = json_endpoint_settings.get('policy_ZA', '7' ) # 30
		#network_interface_desc = '{:s}-NetIf'.format(service_uuid)
		network_interface_desc = json_endpoint_settings.get('ni_description','')
		#network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
		network_subinterface_desc = json_endpoint_settings.get('subif_description','')
		#service_short_uuid = service_uuid.split('-')[-1]
		#network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
		network_instance_name = json_endpoint_settings.get('ni_name', service_uuid.split('-')[-1]) #ELAN-AC:1

		if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)

		json_config_rules = [
		# Configure Interface (not used)
		#json_config_rule_set(
		# '/interface[{:s}]'.format(endpoint_name), {
		# 'name': endpoint_name,
		# 'description': network_interface_desc,
		# 'mtu': mtu,
		#}),

		#Create network instance
		json_config_rule_set(
		'/network_instance[{:s}]'.format(network_instance_name), {
		'name': network_instance_name,
		'description': network_interface_desc,
		'type': 'L3VRF',
		'route_distinguisher': route_distinguisher,
		#'router_id': router_id,
		#'address_families': address_families,
		}),

		#Add BGP protocol to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
		'name': network_instance_name,
		'protocol_name': 'BGP',
		'identifier': 'BGP',
		'type': 'L3VRF',
		'as': bgp_as,
		'router_id': router_id,
		}),

		#Add DIRECTLY CONNECTED protocol to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/protocols[DIRECTLY_CONNECTED]'.format(network_instance_name), {
		'name': network_instance_name,
		'identifier': 'DIRECTLY_CONNECTED',
		'protocol_name': 'DIRECTLY_CONNECTED',
		}),

		#Add STATIC protocol to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/protocols[STATIC]'.format(network_instance_name), {
		'name': network_instance_name,
		'identifier': 'STATIC',
		'protocol_name': 'STATIC',
		}),

		#Create interface with subinterface
		json_config_rule_set(
		'/interface[{:s}]/subinterface[{:d}]'.format(if_subif_name, sub_interface_index), {
		'name' : if_subif_name,
		'type' :'l3ipvlan',
		'mtu' : mtu,
		'index' : sub_interface_index,
		'description' : network_subinterface_desc,
		'vlan_id' : vlan_id,
		'address_ip' : address_ip,
		'address_prefix': address_prefix,
		}),

		#Associate interface to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
		'name' : network_instance_name,
		'type' : 'L3VRF',
		'id' : if_subif_name,
		'interface' : if_subif_name,
		'subinterface': sub_interface_index,
		}),

		#Create routing policy
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_import][{:s}]'.format(policy_import,route_distinguisher), {
		'ext_community_set_name': 'set_{:s}'.format(policy_import),
		'ext_community_member' : route_distinguisher,
		}),
		json_config_rule_set(
		# pylint: disable=duplicate-string-formatting-argument
		'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(policy_import, policy_import), {
		'policy_name' : policy_import,
		'statement_name' : 'stm_{:s}'.format(policy_import),
		'ext_community_set_name': 'set_{:s}'.format(policy_import),
		'policy_result' : 'ACCEPT_ROUTE',
		}),

		#Associate routing policy to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/inter_instance_policies[{:s}]'.format(network_instance_name, policy_import), {
		'name' : network_instance_name,
		'import_policy': policy_import,
		}),

		#Create routing policy
		json_config_rule_set(
		'/routing_policy/bgp_defined_set[{:s}_rt_export][{:s}]'.format(policy_export, route_distinguisher), {
		'ext_community_set_name': 'set_{:s}'.format(policy_export),
		'ext_community_member' : route_distinguisher,
		}),
		json_config_rule_set(
		# pylint: disable=duplicate-string-formatting-argument
		'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(policy_export, policy_export), {
		'policy_name' : policy_export,
		'statement_name' : 'stm_{:s}'.format(policy_export),
		'ext_community_set_name': 'set_{:s}'.format(policy_export),
		'policy_result' : 'ACCEPT_ROUTE',
		}),

		#Associate routing policy to network instance
		json_config_rule_set(
		'/network_instance[{:s}]/inter_instance_policies[{:s}]'.format(network_instance_name, policy_export),{
		'name' : network_instance_name,
		'export_policy': policy_export,
		}),

		#Create table connections
		json_config_rule_set(
		'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(network_instance_name), {
		'name' : network_instance_name,
		'src_protocol' : 'DIRECTLY_CONNECTED',
		'dst_protocol' : 'BGP',
		'address_family' : 'IPV4',
		'default_import_policy': 'ACCEPT_ROUTE',
		}),

		json_config_rule_set(
		'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
		'name' : network_instance_name,
		'src_protocol' : 'STATIC',
		'dst_protocol' : 'BGP',
		'address_family' : 'IPV4',
		'default_import_policy': 'ACCEPT_ROUTE',
		}),

		]

		for res_key, res_value in endpoint_acls:
		json_config_rules.append(
		{'action': 1, 'acl': res_value}
		)
		json_config_rules = []
		return json_config_rules

		def teardown_config_rules(
		@@ -236,61 +77,5 @@ def teardown_config_rules(

		if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)

		json_config_rules = [
		#Delete table connections
		json_config_rule_delete(
		'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(network_instance_name),{
		'name' : network_instance_name,
		'src_protocol' : 'DIRECTLY_CONNECTED',
		'dst_protocol' : 'BGP',
		'address_family': 'IPV4',
		}),


		json_config_rule_delete(
		'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
		'name' : network_instance_name,
		'src_protocol' : 'STATIC',
		'dst_protocol' : 'BGP',
		'address_family': 'IPV4',
		}),

		#Delete export routing policy

		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
		'policy_name': '{:s}_export'.format(network_instance_name),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_export][{:s}]'.format(policy_export, route_distinguisher), {
		'ext_community_set_name': 'set_{:s}'.format(policy_export),
		}),

		#Delete import routing policy

		json_config_rule_delete(
		'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
		'policy_name': '{:s}_import'.format(network_instance_name),
		}),
		json_config_rule_delete(
		'/routing_policy/bgp_defined_set[{:s}_rt_import][{:s}]'.format(policy_import, route_distinguisher), {
		'ext_community_set_name': 'set_{:s}'.format(policy_import),
		}),

		#Delete interface; automatically deletes:
		# - /interface[]/subinterface[]
		json_config_rule_delete('/interface[{:s}]/subinterface[0]'.format(if_subif_name),
		{
		'name': if_subif_name,
		}),

		#Delete network instance; automatically deletes:
		# - /network_instance[]/interface[]
		# - /network_instance[]/protocols[]
		# - /network_instance[]/inter_instance_policies[]
		json_config_rule_delete('/network_instance[{:s}]'.format(network_instance_name),
		{
		'name': network_instance_name
		}),
		]
		json_config_rules = []
		return json_config_rules