diff --git a/manifests/nbiservice.yaml b/manifests/nbiservice.yaml index 27026cc0f8864d012986fb9f7e5c547125930570..acec37d1679b3ec810db284fd62c365a84301c07 100644 --- a/manifests/nbiservice.yaml +++ b/manifests/nbiservice.yaml @@ -68,6 +68,17 @@ spec: limits: cpu: 1000m memory: 2048Mi + # Volume mounts for TE data with IS-IS, BW and latency. Uncomment if needed + # volumeMounts: + # - name: te-data + # mountPath: /var/teraflow/nbi/service/ietf_network/te_data.json + # subPath: te_data.json + # volumes: + # - name: te-data + # hostPath: + # Change this path to the actual path on the node where te_data.json is located + # path: /home/ubuntu/tfs-ctrl/src/nbi/service/ietf_network + # type: Directory --- apiVersion: v1 kind: Service diff --git a/src/nbi/service/ietf_network/Networks.py b/src/nbi/service/ietf_network/Networks.py index e8a69c449e23e84be292b2753e0d3077337e338f..0229b128387a4715cc8a54332821d9e726dcedba 100644 --- a/src/nbi/service/ietf_network/Networks.py +++ b/src/nbi/service/ietf_network/Networks.py @@ -46,6 +46,9 @@ USE_RENDERER = get_setting('IETF_NETWORK_RENDERER', default=DEFAULT_RENDERER.val class Networks(Resource): + def __init__(self, include_te: bool = False): + self.include_te = include_te + @HTTP_AUTH.login_required def get(self): LOGGER.info('Request: {:s}'.format(str(request))) @@ -95,7 +98,7 @@ class Networks(Resource): if topology_details is None: raise Exception(f'Topology({context_name}/{topology_name}) not found') - network_reply = yang_handler.compose_network(topology_name, topology_details) + network_reply = yang_handler.compose_network(topology_name, topology_details, include_te=self.include_te) json_response.append(network_reply) yang_handler.destroy() diff --git a/src/nbi/service/ietf_network/YangHandler.py b/src/nbi/service/ietf_network/YangHandler.py index ea702934fd4c8f2f97b151b3b5825542d40b2d08..15f60830dff18a4dd04a6cf0d3ea46c1e01e4548 100644 --- a/src/nbi/service/ietf_network/YangHandler.py +++ b/src/nbi/service/ietf_network/YangHandler.py @@ -12,8 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import json -import libyang, logging, os +import libyang, logging, os, json, struct from typing import Any from common.proto.context_pb2 import TopologyDetails, Device, Link from .NameMapping import NameMappings @@ -24,7 +23,12 @@ from common.proto.context_pb2 import DeviceId LOGGER = logging.getLogger(__name__) YANG_DIR = os.path.join(os.path.dirname(__file__), 'yang') -YANG_MODULES = ['ietf-network', 'ietf-network-topology', 'ietf-l3-unicast-topology'] +YANG_MODULES = [ + 'ietf-network', 'ietf-network-topology', 'ietf-l3-unicast-topology', + 'ietf-te-types', 'ietf-te-packet-types', + 'ietf-te-topology', 'ietf-l3-te-topology', 'ietf-te-topology-packet', + 'ietf-l3-isis-topology', 'ietf-isis-sr-mpls' +] class YangHandler: def __init__(self) -> None: @@ -33,30 +37,140 @@ class YangHandler: LOGGER.info('Loading module: {:s}'.format(str(yang_module_name))) self._yang_context.load_module(yang_module_name).feature_enable_all() - def compose_network(self, te_topology_name: str, topology_details: TopologyDetails) -> dict: + def _load_te_data(self) -> dict: + te_data_path = os.path.join(os.path.dirname(__file__), 'te_data.json') + if not os.path.exists(te_data_path): + LOGGER.warning('TE data file not found: {:s}'.format(te_data_path)) + return {} + try: + with open(te_data_path, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception as e: + LOGGER.error('Failed to load TE data: {:s}'.format(str(e))) + return {} + + def _to_te_bandwidth(self, val: Any) -> str: + """ + Converts a bandwidth value to the format required by ietf-te-types (hex float). + If the value is already a string starting with '0x', it is assumed to be correct. + Otherwise, it is treated as a decimal (int/float/string) and converted. + Enforces IEEE 754 single precision (float32) and cleans up trailing zeros to match YANG regex. + """ + if isinstance(val, str) and val.strip().lower().startswith('0x'): + return val + + try: + # Enforce 32-bit float precision + f_val = float(val) + f32 = struct.unpack('f', struct.pack('f', f_val))[0] + + # Convert to hex + hex_val = float(f32).hex() + + # Format: 0x1.xxxxxp+yy + # Strip trailing zeros from the mantissa to satisfy the YANG regex (max 5+1 hex digits) + if 'p' in hex_val: + mantissa, exp = hex_val.split('p') + mantissa = mantissa.rstrip('0') + return f"{mantissa}p{exp}" + return hex_val + + except ValueError: + # Fallback to string if conversion fails, though it might error later in libyang + return str(val) + + def get_te_link_key(self, link_name: str) -> str: + """ + Resolves the te_data key for a link. + Supports the new format: entries starting with 'link:' in te_data are matched + against the link name directly or as a suffix. + Falls back to simple substring matching for legacy entries. + """ + te_data = self._load_te_data() + direct_key = f'link:{link_name}' + if direct_key in te_data: + return direct_key + for key in te_data: + if not key.startswith('link:'): + continue + key_name = key[len('link:'):] + if key_name == link_name or key_name in link_name or link_name in key_name: + return key + return link_name + + def _to_uri(self, value: str, type_name: str) -> str: + if ':' in value and value.split(':')[0].lower() in ['urn', 'http', 'https', 'ftp', 'file']: + return value + return f'urn:tfs:{type_name}:{value}' + + def _to_isis_system_id(self, ip_address: str) -> str: + try: + parts = ip_address.split('.') + if len(parts) != 4: return ip_address + padded = ''.join([p.zfill(3) for p in parts]) + return '.'.join([padded[i:i+4] for i in range(0, 12, 4)]) + except: + return ip_address + + def compose_network(self, te_topology_name: str, topology_details: TopologyDetails, include_te: bool = False, include_isis: bool = True) -> dict: networks = self._yang_context.create_data_path('/ietf-network:networks') - network = networks.create_path(f'network[network-id="{te_topology_name}"]') - network.create_path('network-id', te_topology_name) + network_id = self._to_uri(te_topology_name, 'network') + network = networks.create_path(f'network[network-id="{network_id}"]') + network.create_path('network-id', network_id) network_types = network.create_path('network-types') network_types.create_path('ietf-l3-unicast-topology:l3-unicast-topology') + if include_isis: + network_types.create_path('ietf-l3-isis-topology:isis-topology') name_mappings = NameMappings() for device in topology_details.devices: - self.compose_node(device, name_mappings, network) + self.compose_node(device, name_mappings, network, include_isis) for link in topology_details.links: - self.compose_link(link, name_mappings, network) + self.compose_link(link, name_mappings, network, include_te) + + result = json.loads(networks.print_mem('json')) + if include_isis: + te_data = self._load_te_data() + self._inject_isis_tlv_extensions(result, topology_details, te_data) + return result + + def _inject_isis_tlv_extensions(self, result: dict, topology_details: TopologyDetails, te_data: dict) -> None: + """ + Post-processes the YANG JSON dict to inject a custom 'isis-tlv-areas' block + into each node that has TLV data in te_data.json. + This block is outside the YANG schema and provides per-area detail: + loopback, area-address, pfx-sid-index. + """ + device_tlvs = {} + for dev in topology_details.devices: + device_name = dev.name + isis_data, use_tlvs = self._find_node_isis_data(te_data, device_name) + if use_tlvs and isis_data: + tlvs = isis_data.get('TLVs', {}) + if tlvs: + device_tlvs[device_name] = tlvs + + if not device_tlvs: + return + + for network in result.get('ietf-network:networks', {}).get('network', []): + for node in network.get('node', []): + node_id = node.get('node-id', '') + device_name = node_id.split('urn:tfs:node:')[-1] if 'urn:tfs:node:' in node_id else None + if device_name and device_name in device_tlvs: + node['isis-tlv-areas'] = device_tlvs[device_name] - return json.loads(networks.print_mem('json')) - def compose_node(self, dev: Device, name_mappings: NameMappings, network: Any) -> None: + def compose_node(self, dev: Device, name_mappings: NameMappings, network: Any, include_isis: bool = False) -> None: device_name = dev.name name_mappings.store_device_name(dev) - node = network.create_path(f'node[node-id="{device_name}"]') - node.create_path('node-id', device_name) + node_id = self._to_uri(device_name, 'node') + node = network.create_path(f'node[node-id="{node_id}"]') + node.create_path('node-id', node_id) node_attributes = node.create_path('ietf-l3-unicast-topology:l3-node-attributes') node_attributes.create_path('name', device_name) @@ -68,6 +182,88 @@ class YangHandler: self._process_device_config(device, node) + if include_isis: + self._add_isis_attributes(node_attributes, device_name) + + def _find_node_isis_data(self, te_data: dict, device_name: str): + """ + Finds ISIS node attributes in te_data for a given device name. + Supports two formats: + + Format A (old): keyed by device name + "node:Phoenix-4": { "isis_node_attributes": { "node-name": ..., "router-id": [...], ... } } + + Format B (new): keyed by router-id + "node:1.1.1.1": { "isis_node_attributes": { "node-name": "Phoenix-4", "TLVs": { "18201": {...}, ... } } } + + TLV format (B) takes priority over old format (A). + Returns (isis_data, use_tlvs) where use_tlvs is True for Format B. + """ + node_key_suffix = device_name + for key, val in te_data.items(): + if not key.startswith('node:'): + continue + isis_data = val.get('isis_node_attributes', {}) + if 'TLVs' not in isis_data: + continue + node_name = isis_data.get('node-name', '') + key_name = key[len('node:'):] + if node_name == device_name or key_name == device_name: + return isis_data, True + + node_key = f'node:{device_name}' + if node_key in te_data: + isis_data = te_data[node_key].get('isis_node_attributes', {}) + return isis_data, False + + return None, False + + def _add_isis_attributes(self, node_attributes: Any, device_name: str) -> None: + te_data = self._load_te_data() + isis_data, use_tlvs = self._find_node_isis_data(te_data, device_name) + if not isis_data: + return + + isis_attrs = node_attributes.create_path('ietf-l3-isis-topology:isis-node-attributes') + + if 'node-name' in isis_data: + isis_attrs.create_path('node-name', isis_data['node-name']) + + if use_tlvs: + tlvs = isis_data.get('TLVs', {}) + first_tlv = True + added_routers = set() + added_areas = set() + for _tlv_key, tlv_val in tlvs.items(): + if 'loopback' in tlv_val: + rid = tlv_val['loopback'] + if rid not in added_routers: + isis_attrs.create_path('router-id', rid) + added_routers.add(rid) + if 'area-address' in tlv_val: + for area in tlv_val['area-address']: + if area not in added_areas: + isis_attrs.create_path('area-address', area) + added_areas.add(area) + if first_tlv and 'pfx-sid-index' in tlv_val: + isis_attrs.create_path( + 'ietf-isis-sr-mpls:segment-routing-mpls/pfx-sid-index', + tlv_val['pfx-sid-index'] + ) + first_tlv = False + else: + if 'router-id' in isis_data: + for rid in isis_data['router-id']: + isis_attrs.create_path('router-id', rid) + if 'area-address' in isis_data: + for area in isis_data['area-address']: + isis_attrs.create_path('area-address', area) + if 'pfx-sid-index' in isis_data: + isis_attrs.create_path( + 'ietf-isis-sr-mpls:segment-routing-mpls/pfx-sid-index', + isis_data['pfx-sid-index'] + ) + def _process_device_config(self, device: Device, node: Any) -> None: for config in device.device_config.config_rules: if config.WhichOneof('config_rule') != 'custom' or '/interface[' not in config.custom.resource_key: @@ -82,8 +278,9 @@ class YangHandler: def _create_termination_point(self, node: Any, interface_name: str, endpoint_name: str, resource_value: str) -> None: ip_addresses = self._extract_ip_addresses(json.loads(resource_value)) if ip_addresses: - tp = node.create_path(f'ietf-network-topology:termination-point[tp-id="{interface_name}"]') - tp.create_path('tp-id', interface_name) + tp_id = self._to_uri(interface_name, 'tp') + tp = node.create_path(f'ietf-network-topology:termination-point[tp-id="{tp_id}"]') + tp.create_path('tp-id', tp_id) tp_attributes = tp.create_path('ietf-l3-unicast-topology:l3-termination-point-attributes') for ip in ip_addresses: @@ -99,19 +296,54 @@ class YangHandler: ip_addresses.append(resource_value['address_ipv6']) return ip_addresses - def compose_link(self, link_specs: Link, name_mappings: NameMappings, network: Any) -> None: + def compose_link(self, link_specs: Link, name_mappings: NameMappings, network: Any, include_te: bool = False) -> None: link_name = link_specs.name - links = network.create_path(f'ietf-network-topology:link[link-id="{link_name}"]') - links.create_path('link-id', link_name) + link_id = self._to_uri(link_name, 'link') + links = network.create_path(f'ietf-network-topology:link[link-id="{link_id}"]') + links.create_path('link-id', link_id) self._create_link_endpoint(links, 'source', link_specs.link_endpoint_ids[0], name_mappings) self._create_link_endpoint(links, 'destination', link_specs.link_endpoint_ids[-1], name_mappings) + if include_te: + te_data = self._load_te_data() + te_key = self.get_te_link_key(link_name) + if te_key in te_data: + te_info = te_data[te_key] + + te = links.create_path('ietf-te-topology:te') + te_attrs = te.create_path('te-link-attributes') + + max_bw = te_info.get('max_bandwidth', te_info.get('bandwidth')) + if max_bw: + te_attrs.create_path('max-link-bandwidth/te-bandwidth/generic', self._to_te_bandwidth(max_bw)) + + unreserved_bw = te_info.get('unreserved_bandwidth') + if unreserved_bw and isinstance(unreserved_bw, list) and len(unreserved_bw) == 8: + for i, val in enumerate(unreserved_bw): + ub = te_attrs.create_path(f'unreserved-bandwidth[priority="{i}"]') + ub.create_path('priority', i) + ub.create_path('te-bandwidth/generic', self._to_te_bandwidth(val)) + elif 'bandwidth' in te_info: + bw_val = self._to_te_bandwidth(te_info['bandwidth']) + for i in range(8): + ub = te_attrs.create_path(f'unreserved-bandwidth[priority="{i}"]') + ub.create_path('priority', i) + ub.create_path('te-bandwidth/generic', bw_val) + + if 'latency' in te_info: + te_attrs.create_path('ietf-te-topology-packet:performance-metrics-one-way/one-way-delay', int(te_info['latency'])) + + def _create_link_endpoint(self, links: Any, endpoint_type: str, endpoint_id: Any, name_mappings: NameMappings) -> None: endpoint = links.create_path(endpoint_type) if endpoint_type == 'destination': endpoint_type = 'dest' - endpoint.create_path(f'{endpoint_type}-node', name_mappings.get_device_name(endpoint_id.device_id)) - endpoint.create_path(f'{endpoint_type}-tp', name_mappings.get_endpoint_name(endpoint_id)) + + node_name = name_mappings.get_device_name(endpoint_id.device_id) + endpoint.create_path(f'{endpoint_type}-node', self._to_uri(node_name, 'node')) + + tp_name = name_mappings.get_endpoint_name(endpoint_id) + endpoint.create_path(f'{endpoint_type}-tp', self._to_uri(tp_name, 'tp')) def destroy(self) -> None: self._yang_context.destroy() diff --git a/src/nbi/service/ietf_network/__init__.py b/src/nbi/service/ietf_network/__init__.py index 0d153e8eaabd0037a1dfe2d5a2ad72a54a00d676..7d0422b34f11edd7ef6043db286021cb2491a5aa 100644 --- a/src/nbi/service/ietf_network/__init__.py +++ b/src/nbi/service/ietf_network/__init__.py @@ -38,3 +38,4 @@ URL_PREFIX = '/restconf/data/ietf-network:networks' def register_ietf_network(nbi_app : NbiApplication): nbi_app.add_rest_api_resource(Networks, URL_PREFIX + '/') + nbi_app.add_rest_api_resource(Networks, '/restconf/data/ietf-te-topology:networks/', resource_class_kwargs={'include_te': True}, endpoint='ietf_te_topology') diff --git a/src/nbi/service/ietf_network/te_data.json b/src/nbi/service/ietf_network/te_data.json new file mode 100644 index 0000000000000000000000000000000000000000..9e26dfeeb6e641a33dae4961196235bdb965b21b --- /dev/null +++ b/src/nbi/service/ietf_network/te_data.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/src/nbi/service/ietf_network/te_data_example.json b/src/nbi/service/ietf_network/te_data_example.json new file mode 100644 index 0000000000000000000000000000000000000000..cfff1c04ce1e2572d60a4d62b78d628a23e9f9a5 --- /dev/null +++ b/src/nbi/service/ietf_network/te_data_example.json @@ -0,0 +1,63 @@ +{ + "link:CISCO7102:CISCO7112": { + "latency": 134, + "max_bandwidth": "13300000000", + "unreserved_bandwidth": [ + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "0" + ] + }, + "link:Phoenix-4-Phoenix-3": { + "latency": 20, + "max_bandwidth": "12500000000", + "unreserved_bandwidth": [ + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "0" + ] + }, + "node:Phoenix-2": { + "isis_node_attributes": { + "node-name": "Phoenix-2", + "router-id": [ + "1.1.1.1" + ], + "area-address": [ + "49.0001" + ], + "pfx-sid-index": 101 + } + }, + "node:1.1.1.1": { + "isis_node_attributes": { + "node-name": "Phoenix-1", + "TLVs": { + "18201": { + "loopback": "1.1.1.1", + "area-address": [ + "49.0001" + ], + "pfx-sid-index": 201 + }, + "38201": { + "loopback": "2.1.1.2", + "area-address": [ + "49.0002" + ], + "pfx-sid-index": 211 + } + } + } + } +} \ No newline at end of file diff --git a/src/nbi/service/ietf_network/yang/ietf-isis-sr-mpls.yang b/src/nbi/service/ietf_network/yang/ietf-isis-sr-mpls.yang new file mode 100644 index 0000000000000000000000000000000000000000..3dcf1c58fdc1b212c554624fec359c3a4ba293b1 --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-isis-sr-mpls.yang @@ -0,0 +1,35 @@ +module ietf-isis-sr-mpls { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-isis-sr-mpls"; + prefix isis-sr-mpls; + + import ietf-network { + prefix nw; + } + import ietf-l3-unicast-topology { + prefix l3t; + } + import ietf-l3-isis-topology { + prefix isis-topology; + } + + organization + "TeraFlowSDN"; + contact + "TFS"; + description + "IS-IS SR MPLS extensions."; + + revision 2025-02-19 { + description + "Initial revision."; + } + + augment "/nw:networks/nw:network/nw:node/l3t:l3-node-attributes/isis-topology:isis-node-attributes" { + container segment-routing-mpls { + leaf pfx-sid-index { + type uint32; + } + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-isis-topology.yang b/src/nbi/service/ietf_network/yang/ietf-isis-topology.yang new file mode 100644 index 0000000000000000000000000000000000000000..c56fce62b9b49c864fadff48d8cc0819f2eea074 --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-isis-topology.yang @@ -0,0 +1,44 @@ +module ietf-isis-topology { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-isis-topology"; + prefix isis-topology; + + import ietf-network { + prefix nw; + } + import ietf-inet-types { + prefix inet; + } + + organization + "TeraFlowSDN"; + contact + "TFS"; + description + "IS-IS Topology extensions matching user requirements."; + + revision 2025-02-18 { + description + "Initial revision."; + } + + augment "/nw:networks/nw:network/nw:network-types" { + container isis-topology { + presence "Indicates IS-IS topology"; + } + } + + augment "/nw:networks/nw:network/nw:node" { + container isis-node-attributes { + leaf node-name { + type string; + } + leaf-list router-id { + type inet:ip-address; + } + leaf-list area-address { + type string; + } + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-isis@2022-10-19.yang b/src/nbi/service/ietf_network/yang/ietf-isis@2022-10-19.yang new file mode 100644 index 0000000000000000000000000000000000000000..cbbfc0815625f74a6f4c03187ee45caff83c05f7 --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-isis@2022-10-19.yang @@ -0,0 +1,4455 @@ +module ietf-isis { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-isis"; + prefix isis; + + import ietf-routing { + prefix rt; + reference + "RFC 8349: A YANG Data Model for Routing Management + (NMDA Version)"; + } + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-yang-types { + prefix yang; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-interfaces { + prefix if; + reference + "RFC 8343: A YANG Data Model for Interface Management"; + } + import ietf-key-chain { + prefix key-chain; + reference + "RFC 8177: YANG Data Model for Key Chains"; + } + import ietf-routing-types { + prefix rt-types; + reference + "RFC 8294: Common YANG Data Types for the Routing Area"; + } + import iana-routing-types { + prefix iana-rt-types; + reference + "RFC 8294: Common YANG Data Types for the Routing Area"; + } + import ietf-bfd-types { + prefix bfd-types; + reference + "RFC 9314: YANG Data Model for Bidirectional Forwarding + Detection (BFD)"; + } + + organization + "IETF LSR Working Group"; + contact + "WG Web: + WG List: + + Editor: Stephane Litkowski + + + Author: Derek Yeung + + + Author: Acee Lindem + + + Author: Jeffrey Zhang + + + Author: Ladislav Lhotka + "; + description + "This YANG module defines the generic configuration and + operational states for the IS-IS protocol common to all + vendor implementations. It is intended that the module + will be extended by vendors to define vendor-specific + IS-IS configuration parameters and policies - + for example, route maps or route policies. + + This YANG data model conforms to the Network Management + Datastore Architecture (NMDA) as described in RFC 8342. + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2022 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject to + the license terms contained in, the Revised BSD License set + forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 9130; see the + RFC itself for full legal notices."; + reference + "RFC 8342: Network Management Datastore Architecture (NMDA)"; + + revision 2022-10-19 { + description + "Initial revision."; + reference + "RFC 9130: YANG Data Model for the IS-IS Protocol"; + } + + /* Identities */ + + identity isis { + base rt:routing-protocol; + description + "Identity for the IS-IS routing protocol."; + } + + identity lsp-log-reason { + description + "Base identity for a Link State PDU (LSP) + change log reason."; + } + + identity refresh { + base lsp-log-reason; + description + "Identity used when the LSP log reason is that an LSP + refresh was received."; + } + + identity content-change { + base lsp-log-reason; + description + "Identity used when the LSP log reason is + a change in the contents of the LSP."; + } + + identity frr-protection-method { + description + "Base identity for a Fast Reroute protection method."; + } + + identity frr-protection-method-lfa { + base frr-protection-method; + description + "Loop-Free Alternate as defined in RFC 5286."; + reference + "RFC 5286: Basic Specification for IP Fast Reroute: + Loop-Free Alternates"; + } + + identity frr-protection-method-rlfa { + base frr-protection-method; + description + "Remote Loop-Free Alternate as defined in RFC 7490."; + reference + "RFC 7490: Remote Loop-Free Alternate (LFA) + Fast Reroute (FRR)"; + } + + identity frr-protection-method-rsvpte { + base frr-protection-method; + description + "RSVP-TE as defined in RFC 4090."; + reference + "RFC 4090: Fast Reroute Extensions to RSVP-TE for + LSP Tunnels"; + } + + identity frr-protection-available-type { + description + "Base identity for Fast Reroute protection types + provided by an alternate path."; + } + + identity frr-protection-available-node-type { + base frr-protection-available-type; + description + "Node protection is provided by the alternate."; + } + + identity frr-protection-available-link-type { + base frr-protection-available-type; + description + "Link protection is provided by the alternate."; + } + + identity frr-protection-available-srlg-type { + base frr-protection-available-type; + description + "Shared Risk Link Group (SRLG) protection is provided by + the alternate."; + } + + identity frr-protection-available-downstream-type { + base frr-protection-available-type; + description + "The alternate is downstream of the node in the path."; + } + + identity frr-protection-available-other-type { + base frr-protection-available-type; + description + "The level of protection is unknown."; + } + + identity frr-alternate-type { + description + "Base identity for the IP Fast Reroute alternate type."; + } + + identity frr-alternate-type-equal-cost { + base frr-alternate-type; + description + "ECMP-based alternate."; + } + + identity frr-alternate-type-lfa { + base frr-alternate-type; + description + "LFA-based alternate."; + } + + identity frr-alternate-type-remote-lfa { + base frr-alternate-type; + description + "Remote-LFA-based alternate."; + } + + identity frr-alternate-type-tunnel { + base frr-alternate-type; + description + "Tunnel-based alternate (such as RSVP-TE or GRE)."; + } + + identity frr-alternate-mrt { + base frr-alternate-type; + description + "MRT-based alternate."; + } + + identity frr-alternate-tilfa { + base frr-alternate-type; + description + "TI-LFA-based alternate."; + } + + identity frr-alternate-other { + base frr-alternate-type; + description + "Other type of alternate."; + } + + identity unidirectional-link-delay-subtlv-flag { + description + "Base identity for the flag corresponding to the + Unidirectional Link Delay sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity unidirectional-link-delay-subtlv-a-flag { + base unidirectional-link-delay-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity min-max-unidirectional-link-delay-subtlv-flag { + description + "Base identity for the flag corresponding to the Min/Max + Unidirectional Link Delay sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity min-max-unidirectional-link-delay-subtlv-a-flag { + base min-max-unidirectional-link-delay-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity unidirectional-link-loss-subtlv-flag { + description + "Base identity for the flag corresponding to the + Unidirectional Link Loss sub-TLV as defined in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + identity unidirectional-link-loss-subtlv-a-flag { + base unidirectional-link-loss-subtlv-flag; + description + "The 'A' bit field represents the Anomalous (A) bit. + The A bit is set when the measured value of + this parameter exceeds its configured + maximum threshold. + The A bit is cleared when the measured value + falls below its configured reuse threshold. + If the A bit is clear, + the value represents steady-state link performance."; + } + + identity tlv229-flag { + description + "Base identity for the flag corresponding to TLV 229 + (M-Topologies) as defined in RFC 5120."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + + identity tlv229-overload-flag { + base tlv229-flag; + description + "If set, the originator is overloaded + and must be avoided in the path calculation."; + } + + identity tlv229-attached-flag { + base tlv229-flag; + description + "If set, the originator is attached to + another area using the referred metric."; + } + + identity router-capability-flag { + description + "Base identity for the flag corresponding to the + Router Capability TLV as defined in RFC 7981."; + reference + "RFC 7981: IS-IS Extensions for Advertising Router + Information"; + } + + identity router-capability-flooding-flag { + base router-capability-flag; + description + "Quote from RFC 7981: + 'If the S bit is set(1), the IS-IS Router CAPABILITY TLV + MUST be flooded across the entire routing domain. If the + S bit is not set(0), the TLV MUST NOT be leaked between + levels. This bit MUST NOT be altered during the TLV + leaking.'"; + } + + identity router-capability-down-flag { + base router-capability-flag; + description + "Quote from RFC 7981: + 'When the IS-IS Router CAPABILITY TLV is leaked from + Level 2 (L2) to Level 1 (L1), the D bit MUST be set. + Otherwise, this bit MUST be clear. IS-IS Router + CAPABILITY TLVs with the D bit set MUST NOT be leaked from + Level 1 to Level 2. This is to prevent TLV looping.'"; + } + + identity lsp-flag { + description + "Base identity for LSP attributes as defined in ISO 10589."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + + identity lsp-partitioned-flag { + base lsp-flag; + description + "Originator partition repair supported."; + } + + identity lsp-attached-error-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the error metric."; + } + + identity lsp-attached-delay-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the delay metric."; + } + + identity lsp-attached-expense-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the expense metric."; + } + + identity lsp-attached-default-metric-flag { + base lsp-flag; + description + "Set when the originator is attached to + another area using the default metric."; + } + + identity lsp-overload-flag { + base lsp-flag; + description + "If set, the originator is overloaded + and must be avoided in the path calculation."; + } + + identity lsp-l1-system-flag { + base lsp-flag; + description + "Set when the Intermediate System has an L1 type."; + } + + identity lsp-l2-system-flag { + base lsp-flag; + description + "Set when the Intermediate System has an L2 type."; + } + + /* Feature definitions */ + + feature osi-interface { + description + "Support of OSI-specific parameters on an interface."; + } + + feature poi-tlv { + description + "Support of the Purge Originator Identification (POI) TLV."; + reference + "RFC 6232: Purge Originator Identification TLV for IS-IS"; + } + + feature ietf-spf-delay { + description + "Support for the IETF SPF delay algorithm."; + reference + "RFC 8405: Shortest Path First (SPF) Back-Off Delay Algorithm + for Link-State IGPs"; + } + + feature bfd { + description + "Support for detection of IS-IS neighbor reachability + via BFD."; + reference + "RFC 5880: Bidirectional Forwarding Detection (BFD) + RFC 5881: Bidirectional Forwarding Detection (BFD) + for IPv4 and IPv6 (Single Hop)"; + } + + feature key-chain { + description + "Support of key chains for authentication."; + reference + "RFC 8177: YANG Data Model for Key Chains"; + } + + feature node-flag { + description + "Support for node flags for IS-IS prefixes."; + reference + "RFC 7794: IS-IS Prefix Attributes for Extended IPv4 and IPv6 + Reachability"; + } + + feature node-tag { + description + "Support for node administrative tags for IS-IS + routing instances."; + reference + "RFC 7917: Advertising Node Administrative Tags in IS-IS"; + } + + feature ldp-igp-sync { + description + "Support for LDP IGP synchronization."; + reference + "RFC 5443: LDP IGP Synchronization"; + } + + feature fast-reroute { + description + "Support for IP Fast Reroute (IP FRR)."; + } + + feature nsr { + description + "Support for Non-Stop-Routing (NSR). The IS-IS NSR feature + allows a router with redundant control-plane capability + (e.g., dual Route Processor (RP) cards) to maintain its + state and adjacencies during planned and unplanned + IS-IS instance restarts. It differs from graceful restart + or Non-Stop Forwarding (NSF) in that no protocol signaling + or assistance from adjacent IS-IS neighbors is required to + recover control-plane state."; + } + + feature lfa { + description + "Support for Loop-Free Alternates (LFAs)."; + reference + "RFC 5286: Basic Specification for IP Fast Reroute: + Loop-Free Alternates"; + } + + feature remote-lfa { + description + "Support for remote LFAs (R-LFAs)."; + reference + "RFC 7490: Remote Loop-Free Alternate (LFA) + Fast Reroute (FRR)"; + } + + feature overload-max-metric { + description + "Support of overload by setting all links to the maximum + link metric. In IS-IS, the overload bit is usually used to + signal that a node cannot be used as a transit node. The + 'overload-max-metric' feature provides similar behavior, + also setting all the link metrics to MAX_METRIC."; + } + + feature prefix-tag { + description + "Support for 32-bit prefix tags."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + + feature prefix-tag64 { + description + "Support for 64-bit prefix tags."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + + feature auto-cost { + description + "Support for an IS-IS interface metric computation + according to a reference bandwidth."; + } + + feature te-rid { + description + "Traffic Engineering router ID."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering + RFC 6119: IPv6 Traffic Engineering in IS-IS"; + } + + feature max-ecmp { + description + "Sets the maximum number of ECMP paths."; + } + + feature multi-topology { + description + "Support for Multi-Topology (MT) Routing."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + + feature nlpid-control { + description + "Support for the advertisement of a Network Layer + Protocol Identifier within an IS-IS configuration."; + } + + feature graceful-restart { + description + "Support for IS-IS graceful restart."; + reference + "RFC 8706: Restart Signaling for IS-IS"; + } + + feature lsp-refresh { + description + "Configuration of the LSP refresh interval."; + } + + feature maximum-area-addresses { + description + "Support for 'maximum-area-addresses' configuration."; + } + + feature admin-control { + description + "Administrative control of the protocol state."; + } + + /* Type definitions */ + + typedef circuit-id { + type uint8; + description + "This type defines the circuit ID + associated with an interface."; + } + + typedef extended-circuit-id { + type uint32; + description + "This type defines the extended circuit ID + associated with an interface."; + } + + typedef interface-type { + type enumeration { + enum broadcast { + description + "Broadcast interface type."; + } + enum point-to-point { + description + "Point-to-point interface type."; + } + } + description + "This type defines the type of adjacency + to be established for the interface. + 'interface-type' determines the type + of Hello message that is used."; + } + + typedef level { + type enumeration { + enum level-1 { + description + "This enum indicates L1-only capability."; + } + enum level-2 { + description + "This enum indicates L2-only capability."; + } + enum level-all { + description + "This enum indicates capability for both levels."; + } + } + default "level-all"; + description + "This type defines the IS-IS level of an object."; + } + + typedef adj-state-type { + type enumeration { + enum up { + description + "This state indicates that the adjacency is established."; + } + enum down { + description + "This state indicates that the adjacency is + NOT established."; + } + enum init { + description + "This state indicates that the adjacency is being + established."; + } + enum failed { + description + "This state indicates that the adjacency has failed."; + } + } + description + "This type defines the states of an adjacency."; + } + + typedef if-state-type { + type enumeration { + enum up { + description + "'up' state."; + } + enum down { + description + "'down' state."; + } + } + description + "This type defines the state of an interface."; + } + + typedef level-number { + type uint8 { + range "1 .. 2"; + } + description + "This type defines the current IS-IS level."; + } + + typedef lsp-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]' + + '{4}\.[0-9][0-9]-[0-9][0-9]'; + } + description + "This type defines the IS-IS LSP ID format using a + pattern. An example LSP ID is '0143.0438.AEF0.02-01'."; + } + + typedef area-address { + type string { + pattern '[0-9A-Fa-f]{2}(\.[0-9A-Fa-f]{4}){0,6}'; + } + description + "This type defines the area address format."; + } + + typedef snpa { + type string { + length "0 .. 20"; + } + description + "This type defines the Subnetwork Point of Attachment (SNPA) + format. The SNPA should be encoded according to the rules + specified for the particular type of subnetwork being used. + As an example, for an Ethernet subnetwork, the SNPA is + encoded as a Media Access Control (MAC) address, such as + '00aa.bbcc.ddee'."; + } + + typedef system-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}'; + } + description + "This type defines the IS-IS system ID by using a pattern. + An example system ID is '0143.0438.AEF0'."; + } + + typedef extended-system-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.' + + '[0-9][0-9]'; + } + description + "This type defines the IS-IS system ID using a pattern. + 'extended-system-id' contains the pseudonode number + in addition to the system ID. + An example extended system ID is '0143.0438.AEF0.00'."; + } + + typedef wide-metric { + type uint32 { + range "0 .. 16777215"; + } + description + "This type defines the wide-style format of an IS-IS metric."; + } + + typedef std-metric { + type uint8 { + range "0 .. 63"; + } + description + "This type defines the old-style format of the IS-IS metric."; + } + + typedef mesh-group-state { + type enumeration { + enum mesh-inactive { + description + "The interface is not part of a mesh group."; + } + enum mesh-set { + description + "The interface is part of a mesh group."; + } + enum mesh-blocked { + description + "LSPs must not be flooded over this interface."; + } + } + description + "This type describes the mesh group state of an interface."; + } + + /* Grouping for notifications */ + + grouping notification-instance-hdr { + description + "Instance-specific IS-IS notification data grouping."; + leaf routing-protocol-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Name of the IS-IS instance."; + } + leaf isis-level { + type level; + description + "IS-IS level of the instance."; + } + } + + grouping notification-interface-hdr { + description + "Interface-specific IS-IS notification data grouping."; + leaf interface-name { + type if:interface-ref; + description + "IS-IS interface name."; + } + leaf interface-level { + type level; + description + "IS-IS level of the interface."; + } + leaf extended-circuit-id { + type extended-circuit-id; + description + "Extended circuit ID of the interface."; + } + } + + /* Groupings for IP Fast Reroute */ + + grouping instance-fast-reroute-config { + description + "This group defines the global configuration of IP + Fast Reroute (FRR)."; + container fast-reroute { + if-feature "fast-reroute"; + description + "This container may be augmented with global + parameters for IP FRR."; + container lfa { + if-feature "lfa"; + description + "This container may be augmented with + global parameters for Loop-Free Alternates (LFAs). + The creation of this container has no effect on + LFA activation."; + } + } + } + + grouping interface-lfa-config { + leaf candidate-enabled { + type boolean; + default "true"; + description + "Enables the interface to be used as a backup."; + } + leaf enabled { + type boolean; + default "false"; + description + "Activates the LFA. Per-prefix LFA computation is assumed."; + } + container remote-lfa { + if-feature "remote-lfa"; + leaf enabled { + type boolean; + default "false"; + description + "Activates the remote LFA (R-LFA)."; + } + description + "Remote LFA configuration."; + } + description + "Grouping for LFA interface configuration."; + } + + grouping interface-fast-reroute-config { + description + "This group defines the interface configuration of IP FRR."; + container fast-reroute { + if-feature "fast-reroute"; + container lfa { + if-feature "lfa"; + uses interface-lfa-config; + container level-1 { + uses interface-lfa-config; + description + "LFA level-1 configuration."; + } + container level-2 { + uses interface-lfa-config; + description + "LFA level-2 configuration."; + } + description + "LFA configuration."; + } + description + "Interface IP FRR configuration."; + } + } + + grouping instance-fast-reroute-state { + description + "IP FRR state data grouping."; + container protected-routes { + config false; + list address-family-stats { + key "address-family prefix alternate"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf prefix { + type inet:ip-prefix; + description + "Protected prefix."; + } + leaf alternate { + type inet:ip-address; + description + "Alternate next hop for the prefix."; + } + leaf alternate-type { + type identityref { + base frr-alternate-type; + } + description + "Type of alternate."; + } + leaf best { + type boolean; + description + "Set when the alternate is the preferred alternate; + clear otherwise."; + } + leaf non-best-reason { + type string { + length "1..255"; + } + description + "Information field that explains why the alternate + is not the best alternate. The length should be + limited to 255 Unicode characters. The expected format + is a single line of text."; + } + container protection-available { + leaf-list protection-types { + type identityref { + base frr-protection-available-type; + } + description + "This list contains a set of protection + types defined as identities. + An identity must be added for each type of + protection provided by the alternate. + As an example, if an alternate provides + SRLG, node, and link protection, three + identities must be added in this list: + one for SRLG protection, one for node + protection, and one for link protection."; + } + description + "Protection types provided by the alternate."; + } + leaf alternate-metric-1 { + type uint32; + description + "Metric from the Point of Local Repair (PLR) to the + destination through the alternate path."; + } + leaf alternate-metric-2 { + type uint32; + description + "Metric from the PLR to the alternate node."; + } + leaf alternate-metric-3 { + type uint32; + description + "Metric from the alternate node to the destination."; + } + description + "Per-address-family protected prefix statistics."; + } + description + "List of prefixes that are protected."; + } + container unprotected-routes { + config false; + list prefixes { + key "address-family prefix"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf prefix { + type inet:ip-prefix; + description + "Unprotected prefix."; + } + description + "Per-address-family unprotected prefix statistics."; + } + description + "List of prefixes that are not protected."; + } + list protection-statistics { + key "frr-protection-method"; + config false; + leaf frr-protection-method { + type identityref { + base frr-protection-method; + } + description + "Protection method used."; + } + list address-family-stats { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf total-routes { + type yang:gauge32; + description + "Total prefixes."; + } + leaf unprotected-routes { + type yang:gauge32; + description + "Total prefixes that are not protected."; + } + leaf protected-routes { + type yang:gauge32; + description + "Total prefixes that are protected."; + } + leaf link-protected-routes { + type yang:gauge32; + description + "Total prefixes that are link protected."; + } + leaf node-protected-routes { + type yang:gauge32; + description + "Total prefixes that are node protected."; + } + description + "Per-address-family protected prefix statistics."; + } + description + "Global protection statistics."; + } + } + + /* Routing table and local Routing Information Base (RIB) + groupings */ + + grouping local-rib { + description + "Local RIB: RIB for routes computed by the local IS-IS + routing instance."; + container local-rib { + config false; + description + "Local RIB."; + list route { + key "prefix"; + description + "Routes."; + leaf prefix { + type inet:ip-prefix; + description + "Destination prefix."; + } + container next-hops { + description + "Next hops for the route."; + list next-hop { + key "next-hop"; + description + "List of next hops for the route."; + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + leaf next-hop { + type inet:ip-address; + description + "Next-hop address."; + } + } + } + leaf metric { + type uint32; + description + "Metric for this route."; + } + leaf level { + type level-number; + description + "Level number for this route."; + } + leaf route-tag { + type uint32; + description + "Route tag for this route."; + } + } + } + } + + grouping route-content { + description + "IS-IS protocol-specific route properties grouping."; + leaf metric { + type uint32; + description + "IS-IS metric of a route."; + } + leaf-list tag { + type uint64; + description + "List of tags associated with the route. This list + provides a consolidated view of both 32-bit and 64-bit + tags (RFC 5130) available for the prefix."; + reference + "RFC 5130: A Policy Control Mechanism in IS-IS Using + Administrative Tags"; + } + leaf route-type { + type enumeration { + enum l2-intra-area { + description + "Level-2 internal route. As per RFC 5302, + the prefix is directly connected to the + advertising router. It cannot be + distinguished from an L1->L2 inter-area + route."; + reference + "RFC 5302: Domain-Wide Prefix Distribution with + Two-Level IS-IS"; + } + enum l1-intra-area { + description + "Level-1 internal route. As per RFC 5302, + the prefix is directly connected to the + advertising router."; + } + enum l2-external { + description + "Level-2 external route. As per RFC 5302, + such a route is learned from other IGPs. + It cannot be distinguished from an L1->L2 + inter-area external route."; + } + enum l1-external { + description + "Level-1 external route. As per RFC 5302, + such a route is learned from other IGPs."; + } + enum l1-inter-area { + description + "These prefixes are learned via L2 routing."; + } + enum l1-inter-area-external { + description + "These prefixes are learned via L2 routing + towards a level-2 external route."; + } + } + description + "IS-IS route type."; + } + } + + /* Grouping definitions for configuration and operational states */ + + grouping adjacency-state { + container adjacencies { + config false; + list adjacency { + leaf neighbor-sys-type { + type level; + description + "Level capability of the neighboring system."; + } + leaf neighbor-sysid { + type system-id; + description + "The system ID of the neighbor."; + } + leaf neighbor-extended-circuit-id { + type extended-circuit-id; + description + "The circuit ID of the neighbor."; + } + leaf neighbor-snpa { + type snpa; + description + "The SNPA of the neighbor."; + } + leaf usage { + type level; + description + "Defines the level(s) activated for the adjacency. + On a point-to-point link, this might be level 1 and + level 2, but on a LAN, the usage will be level 1 + between neighbors at level 1 or level 2 between + neighbors at level 2."; + } + leaf hold-timer { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "The holding time (in seconds) for this adjacency. + This value is based on received Hello PDUs and the + elapsed time since receipt."; + } + leaf neighbor-priority { + type uint8 { + range "0 .. 127"; + } + description + "Priority of the neighboring IS for becoming the + Designated Intermediate System (DIS)."; + } + leaf lastuptime { + type yang:timestamp; + description + "When the adjacency most recently entered the + 'up' state, measured in hundredths of a + second since the last reinitialization of + the network management subsystem. + The value is 0 if the adjacency has never + been in the 'up' state."; + } + leaf state { + type adj-state-type; + description + "This leaf describes the state of the interface."; + } + description + "List of operational adjacencies."; + } + description + "This container lists the adjacencies of + the local node."; + } + description + "Adjacency state."; + } + + grouping admin-control { + leaf enabled { + if-feature "admin-control"; + type boolean; + default "true"; + description + "Enables or disables the protocol."; + } + description + "Grouping for administrative control."; + } + + grouping ietf-spf-delay { + leaf initial-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "50"; + description + "Delay used while in the QUIET state (milliseconds)."; + } + leaf short-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "200"; + description + "Delay used while in the SHORT_WAIT state (milliseconds)."; + } + leaf long-delay { + type rt-types:timer-value-milliseconds; + units "msec"; + default "5000"; + description + "Delay used while in the LONG_WAIT state (milliseconds)."; + } + leaf hold-down { + type rt-types:timer-value-milliseconds; + units "msec"; + default "10000"; + description + "This timer value defines the period without any changes + for the IGP to be considered stable (in milliseconds)."; + } + leaf time-to-learn { + type rt-types:timer-value-milliseconds; + units "msec"; + default "500"; + description + "Duration used to learn all the IGP events + related to a single network event (milliseconds)."; + } + leaf current-state { + type enumeration { + enum quiet { + description + "QUIET state."; + } + enum short-wait { + description + "SHORT_WAIT state."; + } + enum long-wait { + description + "LONG_WAIT state."; + } + } + config false; + description + "Current SPF Back-Off algorithm state."; + } + leaf remaining-time-to-learn { + type rt-types:timer-value-milliseconds; + units "msec"; + config false; + description + "Remaining time until the time-to-learn timer fires."; + } + leaf remaining-hold-down { + type rt-types:timer-value-milliseconds; + units "msec"; + config false; + description + "Remaining time until the hold-down timer fires."; + } + leaf last-event-received { + type yang:timestamp; + config false; + description + "Time of the last IGP event received."; + } + leaf next-spf-time { + type yang:timestamp; + config false; + description + "Time when the next SPF has been scheduled."; + } + leaf last-spf-time { + type yang:timestamp; + config false; + description + "Time of the last SPF computation."; + } + description + "Grouping for IETF SPF delay configuration and state."; + reference + "RFC 8405: Shortest Path First (SPF) Back-Off Delay Algorithm + for Link-State IGPs"; + } + + grouping node-tag-config { + description + "IS-IS node tag configuration state."; + container node-tags { + if-feature "node-tag"; + list node-tag { + key "tag"; + leaf tag { + type uint32; + description + "Node tag value."; + } + description + "List of tags."; + } + description + "Container for node administrative tags."; + } + } + + grouping authentication-global-cfg { + choice authentication-type { + case key-chain { + if-feature "key-chain"; + leaf key-chain { + type key-chain:key-chain-ref; + description + "Reference to a key chain."; + } + } + case password { + leaf key { + type string; + description + "This leaf specifies the authentication key. The + length of the key may be dependent on the + cryptographic algorithm."; + } + leaf crypto-algorithm { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Cryptographic algorithm associated with a key."; + } + } + description + "Choice of authentication."; + } + description + "Grouping for global authentication configuration."; + } + + grouping metric-type-global-cfg { + leaf value { + type enumeration { + enum wide-only { + description + "Advertises the new metric style only (RFC 5305)."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + } + enum old-only { + description + "Advertises the old metric style only (RFC 1195)."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + } + enum both { + description + "Advertises both metric styles."; + } + } + description + "Type of metric to be generated: + + - 'wide-only' means that only a new metric style + is generated. + - 'old-only' means that only an old metric style + is generated. + - 'both' means that both are advertised. + + This leaf only affects IPv4 metrics."; + } + description + "Grouping for global metric style configuration."; + } + + grouping metric-type-global-cfg-with-default { + leaf value { + type enumeration { + enum wide-only { + description + "Advertises the new metric style only (RFC 5305)."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + } + enum old-only { + description + "Advertises the old metric style only (RFC 1195)."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + } + enum both { + description + "Advertises both metric styles."; + } + } + default "wide-only"; + description + "Type of metric to be generated: + + - 'wide-only' means that only a new metric style + is generated. + - 'old-only' means that only an old metric style + is generated. + - 'both' means that both are advertised. + + This leaf only affects IPv4 metrics."; + } + description + "Grouping for global metric style configuration."; + } + + grouping default-metric-global-cfg { + leaf value { + type wide-metric; + description + "Value of the metric."; + } + description + "Global default metric configuration grouping."; + } + + grouping default-metric-global-cfg-with-default { + leaf value { + type wide-metric; + default "10"; + description + "Value of the metric."; + } + description + "Global default metric configuration grouping."; + } + + grouping overload-global-cfg { + leaf status { + type boolean; + default "false"; + description + "This leaf specifies the overload status."; + } + description + "Grouping for overload bit configuration."; + } + + grouping overload-max-metric-global-cfg { + leaf timeout { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Timeout (in seconds) of the overload condition."; + } + description + "Overload maximum metric configuration grouping."; + } + + grouping route-preference-global-cfg { + choice granularity { + case detail { + leaf internal { + type uint8; + description + "Protocol preference for internal routes."; + } + leaf external { + type uint8; + description + "Protocol preference for external routes."; + } + } + case coarse { + leaf default { + type uint8; + description + "Protocol preference for all IS-IS routes."; + } + } + description + "Choice for implementation of route preference."; + } + description + "Global route preference grouping."; + } + + grouping hello-authentication-cfg { + choice authentication-type { + case key-chain { + if-feature "key-chain"; + leaf key-chain { + type key-chain:key-chain-ref; + description + "Reference to a key chain."; + } + } + case password { + leaf key { + type string; + description + "Authentication key specification. The length of the + key may be dependent on the cryptographic algorithm."; + } + leaf crypto-algorithm { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Cryptographic algorithm associated with a key."; + } + } + description + "Choice of authentication."; + } + description + "Grouping for Hello authentication."; + } + + grouping hello-interval-cfg { + leaf value { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) between successive Hello + messages."; + } + description + "Interval between Hello messages."; + } + + grouping hello-interval-cfg-with-default { + leaf value { + type rt-types:timer-value-seconds16; + units "seconds"; + default "10"; + description + "Interval (in seconds) between successive Hello + messages."; + } + description + "Interval between Hello messages."; + } + + grouping hello-multiplier-cfg { + leaf value { + type uint16; + description + "Number of missed Hello messages prior to + declaring the adjacency down."; + } + description + "Grouping for the number of missed Hello messages prior to + declaring the adjacency down."; + } + + grouping hello-multiplier-cfg-with-default { + leaf value { + type uint16; + default "3"; + description + "Number of missed Hello messages prior to + declaring the adjacency down."; + } + description + "Grouping for the number of missed Hello messages prior to + declaring the adjacency down."; + } + + grouping priority-cfg { + leaf value { + type uint8 { + range "0 .. 127"; + } + description + "Priority of the interface for DIS election."; + } + description + "Interface DIS election priority grouping."; + } + + grouping priority-cfg-with-default { + leaf value { + type uint8 { + range "0 .. 127"; + } + default "64"; + description + "Priority of the interface for DIS election."; + } + description + "Interface DIS election priority grouping."; + } + + grouping metric-cfg { + leaf value { + type wide-metric; + description + "Metric value."; + } + description + "Interface metric grouping."; + } + + grouping metric-cfg-with-default { + leaf value { + type wide-metric; + default "10"; + description + "Metric value."; + } + description + "Interface metric grouping."; + } + + grouping metric-parameters { + container metric-type { + uses metric-type-global-cfg-with-default; + container level-1 { + uses metric-type-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-type-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric style global configuration."; + } + container default-metric { + uses default-metric-global-cfg-with-default; + container level-1 { + uses default-metric-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses default-metric-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Default metric global configuration."; + } + container auto-cost { + if-feature "auto-cost"; + description + "Interface auto-cost configuration state."; + leaf enabled { + type boolean; + description + "Enables or disables interface auto-cost."; + } + leaf reference-bandwidth { + when "../enabled = 'true'" { + description + "Only when auto-cost is enabled."; + } + type uint32 { + range "1..4294967"; + } + units "Mbits"; + description + "Configures the reference bandwidth used to automatically + determine the interface cost (Mbits). The cost is the + reference bandwidth divided by the interface speed, + with 1 being the minimum cost."; + } + } + description + "Grouping for global metric parameters."; + } + + grouping high-availability-parameters { + container graceful-restart { + if-feature "graceful-restart"; + leaf enabled { + type boolean; + default "false"; + description + "Enables graceful restart."; + } + leaf restart-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) to attempt graceful restart prior + to failure."; + } + leaf helper-enabled { + type boolean; + default "true"; + description + "Enables a local IS-IS router as a graceful restart + helper."; + } + description + "Configuration of graceful restart."; + } + container nsr { + if-feature "nsr"; + description + "Non-Stop Routing (NSR) configuration."; + leaf enabled { + type boolean; + default "false"; + description + "Enables or disables NSR."; + } + } + description + "Grouping for high-availability parameters."; + } + + grouping authentication-parameters { + container authentication { + uses authentication-global-cfg; + container level-1 { + uses authentication-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses authentication-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Authentication global configuration for + both LSPs and Sequence Number PDUs (SNPs)."; + } + description + "Grouping for authentication parameters."; + } + + grouping address-family-parameters { + container address-families { + if-feature "nlpid-control"; + list address-family-list { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + leaf enabled { + type boolean; + description + "Activates the address family."; + } + description + "List of address families and whether or not they + are activated."; + } + description + "Address family configuration."; + } + description + "Grouping for address family parameters."; + } + + grouping mpls-parameters { + container mpls { + container te-rid { + if-feature "te-rid"; + description + "Stable IS-IS router IP address used for Traffic + Engineering."; + leaf ipv4-router-id { + type inet:ipv4-address; + description + "Router ID value that would be used in TLV 134."; + } + leaf ipv6-router-id { + type inet:ipv6-address; + description + "Router ID value that would be used in TLV 140."; + } + } + container ldp { + container igp-sync { + if-feature "ldp-igp-sync"; + description + "This container may be augmented with global + parameters for LDP IGP synchronization."; + } + description + "LDP configuration."; + } + description + "MPLS configuration."; + } + description + "Grouping for MPLS global parameters."; + } + + grouping lsp-parameters { + leaf lsp-mtu { + type uint16; + units "bytes"; + default "1492"; + description + "Maximum size of an LSP PDU in bytes."; + } + leaf lsp-lifetime { + type uint16 { + range "1..65535"; + } + units "seconds"; + description + "Lifetime of the router's LSPs in seconds."; + } + leaf lsp-refresh { + if-feature "lsp-refresh"; + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Refresh interval of the router's LSPs in seconds."; + } + leaf poi-tlv { + if-feature "poi-tlv"; + type boolean; + default "false"; + description + "Enables the advertisement of the IS-IS Purge Originator + Identification TLV."; + } + description + "Grouping for LSP global parameters."; + } + + grouping spf-parameters { + container spf-control { + leaf paths { + if-feature "max-ecmp"; + type uint16 { + range "1..65535"; + } + description + "Maximum number of Equal-Cost Multi-Path (ECMP) paths."; + } + container ietf-spf-delay { + if-feature "ietf-spf-delay"; + uses ietf-spf-delay; + description + "IETF SPF delay algorithm configuration."; + } + description + "SPF calculation control."; + } + description + "Grouping for SPF global parameters."; + } + + grouping instance-config { + description + "IS-IS global configuration grouping."; + uses admin-control; + leaf level-type { + type level; + default "level-all"; + description + "Level of an IS-IS node. Can be 'level-1', 'level-2', or + 'level-all'."; + } + leaf system-id { + type system-id; + description + "System ID of the node."; + } + leaf maximum-area-addresses { + if-feature "maximum-area-addresses"; + type uint8; + default "3"; + description + "Maximum areas supported."; + } + leaf-list area-address { + type area-address; + description + "List of areas supported by the protocol instance."; + } + uses lsp-parameters; + uses high-availability-parameters; + uses node-tag-config; + uses metric-parameters; + uses authentication-parameters; + uses address-family-parameters; + uses mpls-parameters; + uses spf-parameters; + uses instance-fast-reroute-config; + container preference { + uses route-preference-global-cfg; + description + "Router preference configuration for IS-IS + protocol instance route installation."; + } + container overload { + uses overload-global-cfg; + description + "Router protocol instance overload state configuration."; + } + container overload-max-metric { + if-feature "overload-max-metric"; + uses overload-max-metric-global-cfg; + description + "Router protocol instance overload maximum + metric advertisement configuration."; + } + } + + grouping instance-state { + description + "IS-IS instance operational state."; + uses spf-log; + uses lsp-log; + uses hostname-db; + uses lsdb; + uses local-rib; + uses system-counters; + uses instance-fast-reroute-state; + leaf discontinuity-time { + type yang:date-and-time; + description + "The time of the most recent occasion at which any one + or more of this IS-IS instance's counters suffered a + discontinuity. If no such discontinuities have occurred + since the IS-IS instance was last reinitialized, then + this node contains the time the IS-IS instance was + reinitialized, which normally occurs when it was + created."; + } + } + + grouping multi-topology-config { + description + "Per-topology configuration."; + container default-metric { + uses default-metric-global-cfg; + container level-1 { + uses default-metric-global-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses default-metric-global-cfg; + description + "Configuration specific to level 2."; + } + description + "Default metric per-topology configuration."; + } + uses node-tag-config; + } + + grouping interface-config { + description + "Interface configuration grouping."; + uses admin-control; + leaf level-type { + type level; + default "level-all"; + description + "IS-IS level of the interface."; + } + leaf lsp-pacing-interval { + type rt-types:timer-value-milliseconds; + units "milliseconds"; + default "33"; + description + "Interval (in milliseconds) between LSP transmissions."; + } + leaf lsp-retransmit-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + description + "Interval (in seconds) between LSP retransmissions."; + } + leaf passive { + type boolean; + default "false"; + description + "Indicates whether the interface is in passive mode (IS-IS + is not running, but the network is advertised)."; + } + leaf csnp-interval { + type rt-types:timer-value-seconds16; + units "seconds"; + default "10"; + description + "Interval (in seconds) between Complete Sequence Number + Packet (CSNP) messages."; + } + container hello-padding { + leaf enabled { + type boolean; + default "true"; + description + "IS-IS Hello padding activation. Enabled by default."; + } + description + "IS-IS Hello padding configuration."; + } + leaf mesh-group-enabled { + type mesh-group-state; + description + "IS-IS interface mesh group state."; + } + leaf mesh-group { + when "../mesh-group-enabled = 'mesh-set'" { + description + "Only valid when 'mesh-group-enabled' equals 'mesh-set'."; + } + type uint8; + description + "IS-IS interface mesh group ID."; + } + leaf interface-type { + type interface-type; + default "broadcast"; + description + "Type of adjacency to be established for the interface. + This dictates the type of Hello messages that are used."; + } + leaf-list tag { + if-feature "prefix-tag"; + type uint32; + description + "List of tags associated with the interface."; + } + leaf-list tag64 { + if-feature "prefix-tag64"; + type uint64; + description + "List of 64-bit tags associated with the interface."; + } + leaf node-flag { + if-feature "node-flag"; + type boolean; + default "false"; + description + "Sets the prefix as a node representative prefix."; + } + container hello-authentication { + uses hello-authentication-cfg; + container level-1 { + uses hello-authentication-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-authentication-cfg; + description + "Configuration specific to level 2."; + } + description + "Authentication type to be used in Hello messages."; + } + container hello-interval { + uses hello-interval-cfg-with-default; + container level-1 { + uses hello-interval-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-interval-cfg; + description + "Configuration specific to level 2."; + } + description + "Interval between Hello messages."; + } + container hello-multiplier { + uses hello-multiplier-cfg-with-default; + container level-1 { + uses hello-multiplier-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses hello-multiplier-cfg; + description + "Configuration specific to level 2."; + } + description + "Hello multiplier configuration."; + } + container priority { + must '../interface-type = "broadcast"' { + error-message "Priority only applies to broadcast " + + "interfaces."; + description + "Checks for a broadcast interface."; + } + uses priority-cfg-with-default; + container level-1 { + uses priority-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses priority-cfg; + description + "Configuration specific to level 2."; + } + description + "Priority for DIS election."; + } + container metric { + uses metric-cfg-with-default; + container level-1 { + uses metric-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric configuration."; + } + container bfd { + if-feature "bfd"; + description + "BFD interface configuration."; + uses bfd-types:client-cfg-parms; + reference + "RFC 5880: Bidirectional Forwarding Detection (BFD) + RFC 5881: Bidirectional Forwarding Detection + (BFD) for IPv4 and IPv6 (Single Hop) + RFC 9314: YANG Data Model for Bidirectional Forwarding + Detection (BFD)"; + } + container address-families { + if-feature "nlpid-control"; + list address-family-list { + key "address-family"; + leaf address-family { + type iana-rt-types:address-family; + description + "Address family."; + } + description + "List of address families."; + } + description + "Interface address families."; + } + container mpls { + container ldp { + leaf igp-sync { + if-feature "ldp-igp-sync"; + type boolean; + default "false"; + description + "Enables IGP/LDP synchronization."; + } + description + "Configuration related to LDP."; + } + description + "MPLS configuration for IS-IS interfaces."; + } + uses interface-fast-reroute-config; + } + + grouping multi-topology-interface-config { + description + "IS-IS interface topology configuration."; + container metric { + uses metric-cfg; + container level-1 { + uses metric-cfg; + description + "Configuration specific to level 1."; + } + container level-2 { + uses metric-cfg; + description + "Configuration specific to level 2."; + } + description + "Metric IS-IS interface configuration."; + } + } + + grouping interface-state { + description + "IS-IS interface operational state."; + uses adjacency-state; + uses event-counters; + uses packet-counters; + leaf discontinuity-time { + type yang:date-and-time; + description + "The time of the most recent occasion at which any one + or more of this IS-IS interface's counters suffered a + discontinuity. If no such discontinuities have occurred + since the IS-IS interface was last reinitialized, then + this node contains the time the IS-IS interface was + reinitialized, which normally occurs when it was + created."; + } + } + + /* Grouping for the hostname database */ + + grouping hostname-db { + container hostnames { + config false; + list hostname { + key "system-id"; + leaf system-id { + type system-id; + description + "System ID associated with the hostname."; + } + leaf hostname { + type string { + length "1..255"; + } + description + "Hostname associated with the system ID + as defined in RFC 5301."; + reference + "RFC 5301: Dynamic Hostname Exchange Mechanism + for IS-IS"; + } + description + "List of system ID / hostname associations."; + } + description + "Hostname-to-system-ID mapping database."; + } + description + "Grouping for hostname-to-system-ID mapping database."; + } + + /* Groupings for counters */ + + grouping system-counters { + container system-counters { + config false; + list level { + key "level"; + leaf level { + type level-number; + description + "IS-IS level."; + } + leaf corrupted-lsps { + type uint32; + description + "Number of corrupted in-memory LSPs detected. + LSPs received from the wire with a bad + checksum are silently dropped and not counted. + LSPs received from the wire with parse errors + are counted by 'lsp-errors'."; + } + leaf authentication-type-fails { + type uint32; + description + "Number of authentication type mismatches."; + } + leaf authentication-fails { + type uint32; + description + "Number of authentication key failures."; + } + leaf database-overload { + type uint32; + description + "Number of times the database has become + overloaded."; + } + leaf own-lsp-purge { + type uint32; + description + "Number of times a zero-aged copy of the system's + own LSP is received from some other IS-IS node."; + } + leaf manual-address-drop-from-area { + type uint32; + description + "Number of times a manual address + has been dropped from the area."; + } + leaf max-sequence { + type uint32; + description + "Number of times the system has attempted + to exceed the maximum sequence number."; + } + leaf sequence-number-skipped { + type uint32; + description + "Number of times a sequence number skip has + occurred."; + } + leaf id-len-mismatch { + type uint32; + description + "Number of times a PDU is received with a + different value for the ID field length + than that of the receiving system."; + } + leaf partition-changes { + type uint32; + description + "Number of partition changes detected."; + } + leaf lsp-errors { + type uint32; + description + "Number of LSPs received with errors."; + } + leaf spf-runs { + type uint32; + description + "Number of times SPF was run at this level."; + } + description + "List of supported levels."; + } + description + "List of counters for the IS-IS protocol instance."; + } + description + "Grouping for IS-IS system counters."; + } + + grouping event-counters { + container event-counters { + config false; + leaf adjacency-changes { + type uint32; + description + "The number of times an adjacency state change has + occurred on this interface."; + } + leaf adjacency-number { + type uint32; + description + "The number of adjacencies on this interface."; + } + leaf init-fails { + type uint32; + description + "The number of times initialization of this interface has + failed. This counts events such as Point-to-Point + Protocol (PPP) Network Control Protocol (NCP) failures. + Failures to form an adjacency are counted by + 'adjacency-rejects'."; + } + leaf adjacency-rejects { + type uint32; + description + "The number of times an adjacency has been + rejected on this interface."; + } + leaf id-len-mismatch { + type uint32; + description + "The number of times an IS-IS PDU with an ID + field length different from that for this + system has been received on this interface."; + } + leaf max-area-addresses-mismatch { + type uint32; + description + "The number of times an IS-IS PDU has been + received on this interface with the + max area address field differing from that of + this system."; + } + leaf authentication-type-fails { + type uint32; + description + "Number of authentication type mismatches."; + } + leaf authentication-fails { + type uint32; + description + "Number of authentication key failures."; + } + leaf lan-dis-changes { + type uint32; + description + "The number of times the DIS has changed on this + interface at this level. If the interface type is + 'point-to-point', the count is zero."; + } + description + "IS-IS interface event counters."; + } + description + "Grouping for IS-IS interface event counters."; + } + + grouping packet-counters { + container packet-counters { + config false; + list level { + key "level"; + leaf level { + type level-number; + description + "IS-IS level."; + } + container iih { + leaf in { + type uint32; + description + "Received IS-IS Hello (IIH) PDUs."; + } + leaf out { + type uint32; + description + "Sent IIH PDUs."; + } + description + "Number of IIH PDUs received/sent."; + } + container ish { + leaf in { + type uint32; + description + "Received Intermediate System Hello (ISH) PDUs."; + } + leaf out { + type uint32; + description + "Sent ISH PDUs."; + } + description + "ISH PDUs received/sent."; + } + container esh { + leaf in { + type uint32; + description + "Received End System Hello (ESH) PDUs."; + } + leaf out { + type uint32; + description + "Sent ESH PDUs."; + } + description + "Number of ESH PDUs received/sent."; + } + container lsp { + leaf in { + type uint32; + description + "Received Link State PDU (LSP) PDUs."; + } + leaf out { + type uint32; + description + "Sent LSP PDUs."; + } + description + "Number of LSP PDUs received/sent."; + } + container psnp { + leaf in { + type uint32; + description + "Received Partial Sequence Number PDU (PSNP) PDUs."; + } + leaf out { + type uint32; + description + "Sent PSNP PDUs."; + } + description + "Number of PSNP PDUs received/sent."; + } + container csnp { + leaf in { + type uint32; + description + "Received Complete Sequence Number PDU (CSNP) PDUs."; + } + leaf out { + type uint32; + description + "Sent CSNP PDUs."; + } + description + "Number of CSNP PDUs received/sent."; + } + container unknown { + leaf in { + type uint32; + description + "Received unknown PDUs."; + } + description + "Number of unknown PDUs received."; + } + description + "List of packet counters for supported levels."; + } + description + "Packet counters per IS-IS level."; + } + description + "Grouping for packet counters per IS-IS level."; + } + + /* Groupings for various log buffers */ + + grouping spf-log { + container spf-log { + config false; + list event { + key "id"; + leaf id { + type yang:counter32; + description + "Event identifier. A purely internal value. + The most recent events are expected to have a bigger + ID number."; + } + leaf spf-type { + type enumeration { + enum full { + description + "Full SPF computation."; + } + enum route-only { + description + "SPF computation of route reachability + only."; + } + } + description + "Type of SPF computation performed."; + } + leaf level { + type level-number; + description + "IS-IS level number for the SPF computation."; + } + leaf schedule-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation was + scheduled."; + } + leaf start-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation started."; + } + leaf end-timestamp { + type yang:timestamp; + description + "Timestamp of when the SPF computation ended."; + } + list trigger-lsp { + key "lsp"; + leaf lsp { + type lsp-id; + description + "LSP ID of the LSP that triggered the SPF + computation."; + } + leaf sequence { + type uint32; + description + "Sequence number of the LSP that triggered the SPF + computation."; + } + description + "This list includes the LSPs that triggered the + SPF computation."; + } + description + "List of computation events. Implemented as a + wrapping buffer."; + } + description + "This container lists the SPF computation events."; + } + description + "Grouping for SPF log events."; + } + + grouping lsp-log { + container lsp-log { + config false; + list event { + key "id"; + leaf id { + type yang:counter32; + description + "Event identifier. A purely internal value. + The most recent events are expected to have a bigger + ID number."; + } + leaf level { + type level-number; + description + "IS-IS level number for the LSP."; + } + container lsp { + leaf lsp { + type lsp-id; + description + "LSP ID of the LSP."; + } + leaf sequence { + type uint32; + description + "Sequence number of the LSP."; + } + description + "LSP identification container for either the received + LSP or the locally generated LSP."; + } + leaf received-timestamp { + type yang:timestamp; + description + "This is the timestamp when the LSP was received. + In the case of a local LSP update, the timestamp refers + to the LSP origination time."; + } + leaf reason { + type identityref { + base lsp-log-reason; + } + description + "Type of LSP change."; + } + description + "List of LSP events. Implemented as a wrapping buffer."; + } + description + "This container lists the LSP log. + Local LSP modifications are also included in the list."; + } + description + "Grouping for the LSP log."; + } + + /* Groupings for the Link State Database (LSDB) descriptions */ + /* Unknown TLV and sub-TLV descriptions */ + + grouping tlv { + description + "Type-Length-Value (TLV)."; + leaf type { + type uint16; + description + "TLV type."; + } + leaf length { + type uint16; + description + "TLV length (octets)."; + } + leaf value { + type yang:hex-string; + description + "TLV value."; + } + } + + grouping unknown-tlvs { + description + "Unknown TLVs grouping. Used for unknown TLVs or + unknown sub-TLVs."; + container unknown-tlvs { + description + "All unknown TLVs."; + list unknown-tlv { + description + "Unknown TLV."; + uses tlv; + } + } + } + + /* TLVs and sub-TLVs for prefixes */ + + grouping prefix-reachability-attributes { + description + "Grouping for extended reachability attributes of an + IPv4 or IPv6 prefix."; + leaf external-prefix-flag { + type boolean; + description + "External prefix flag."; + } + leaf readvertisement-flag { + type boolean; + description + "Re-advertisement flag."; + } + leaf node-flag { + type boolean; + description + "Node flag."; + } + } + + grouping prefix-ipv4-source-router-id { + description + "Grouping for the IPv4 source router ID of a prefix + advertisement."; + leaf ipv4-source-router-id { + type inet:ipv4-address; + description + "IPv4 source router ID address."; + } + } + + grouping prefix-ipv6-source-router-id { + description + "Grouping for the IPv6 source router ID of a prefix + advertisement."; + leaf ipv6-source-router-id { + type inet:ipv6-address; + description + "IPv6 source router ID address."; + } + } + + grouping prefix-attributes-extension { + description + "Prefix extended attributes as defined in RFC 7794."; + reference + "RFC 7794: IS-IS Prefix Attributes for Extended IPv4 and IPv6 + Reachability"; + uses prefix-reachability-attributes; + uses prefix-ipv4-source-router-id; + uses prefix-ipv6-source-router-id; + } + + grouping prefix-ipv4-std { + description + "Grouping for attributes of an IPv4 standard prefix + as defined in RFC 1195."; + reference + "RFC 1195: Use of OSI IS-IS for routing in TCP/IP and + dual environments"; + leaf ip-prefix { + type inet:ipv4-address; + description + "IPv4 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv4 prefix length (in bits)."; + } + leaf i-e { + type boolean; + description + "Internal or external (I/E) metric bit value. + Set to 'false' to indicate an internal metric."; + } + container default-metric { + leaf metric { + type std-metric; + description + "Default IS-IS metric for the IPv4 prefix."; + } + description + "IS-IS default metric container."; + } + container delay-metric { + leaf metric { + type std-metric; + description + "IS-IS delay metric for the IPv4 prefix."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS delay metric is supported."; + } + description + "IS-IS delay metric container."; + } + container expense-metric { + leaf metric { + type std-metric; + description + "IS-IS expense metric for the IPv4 prefix."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS expense metric is supported."; + } + description + "IS-IS expense metric container."; + } + container error-metric { + leaf metric { + type std-metric; + description + "This leaf describes the IS-IS error metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "Indicates whether the IS-IS error metric is supported."; + } + description + "IS-IS error metric container."; + } + } + + grouping prefix-ipv4-extended { + description + "Grouping for attributes of an IPv4 extended prefix + as defined in RFC 5305."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + leaf up-down { + type boolean; + description + "Value of the up/down bit. + Set to 'true' when the prefix has been advertised down + the hierarchy."; + } + leaf ip-prefix { + type inet:ipv4-address; + description + "IPv4 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv4 prefix length (in bits)."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric value."; + } + leaf-list tag { + type uint32; + description + "List of 32-bit tags associated with the IPv4 prefix."; + } + leaf-list tag64 { + type uint64; + description + "List of 64-bit tags associated with the IPv4 prefix."; + } + uses prefix-attributes-extension; + } + + grouping prefix-ipv6-extended { + description + "Grouping for attributes of an IPv6 prefix + as defined in RFC 5308."; + reference + "RFC 5308: Routing IPv6 with IS-IS"; + leaf up-down { + type boolean; + description + "Value of the up/down bit. + Set to 'true' when the prefix has been advertised down + the hierarchy."; + } + leaf ip-prefix { + type inet:ipv6-address; + description + "IPv6 prefix address."; + } + leaf prefix-len { + type uint8; + description + "IPv6 prefix length (in bits)."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric value."; + } + leaf-list tag { + type uint32; + description + "List of 32-bit tags associated with the IPv6 prefix."; + } + leaf-list tag64 { + type uint64; + description + "List of 64-bit tags associated with the IPv6 prefix."; + } + uses prefix-attributes-extension; + } + + /* TLVs and sub-TLVs for neighbors */ + + grouping neighbor-link-attributes { + description + "Grouping for link attributes as defined + in RFC 5029."; + reference + "RFC 5029: Definition of an IS-IS Link Attribute Sub-TLV"; + leaf link-attributes-flags { + type uint16; + description + "Flags for the link attributes."; + } + } + + grouping neighbor-gmpls-extensions { + description + "Grouping for GMPLS attributes of a neighbor as defined + in RFC 5307."; + reference + "RFC 5307: IS-IS Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS)"; + leaf link-local-id { + type uint32; + description + "Local identifier of the link."; + } + leaf remote-local-id { + type uint32; + description + "Remote identifier of the link."; + } + leaf protection-capability { + type uint8; + description + "Describes the protection capabilities + of the link. This is the value of the + first octet of the sub-TLV type 20 value."; + } + container interface-switching-capability { + description + "Interface switching capabilities of the link."; + leaf switching-capability { + type uint8; + description + "Switching capability of the link."; + } + leaf encoding { + type uint8; + description + "Type of encoding of the LSP being used."; + } + container max-lsp-bandwidths { + description + "Per-priority maximum LSP bandwidths."; + list max-lsp-bandwidth { + leaf priority { + type uint8 { + range "0 .. 7"; + } + description + "Priority from 0 to 7."; + } + leaf bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum LSP bandwidth."; + } + description + "List of maximum LSP bandwidths for different + priorities."; + } + } + container tdm-specific { + when '../switching-capability = 100'; + description + "Switching-capability-specific information applicable + when the switching type is Time-Division Multiplexing + (TDM)."; + leaf minimum-lsp-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Minimum LSP bandwidth."; + } + leaf indication { + type uint8; + description + "Indicates whether the interface supports Standard + or Arbitrary SONET/SDH (Synchronous Optical Network / + Synchronous Digital Hierarchy)."; + } + } + container psc-specific { + when "../switching-capability >= 1 and + ../switching-capability <= 4"; + description + "Switching-capability-specific information applicable + when the switching type is PSC1, PSC2, PSC3, or PSC4 + ('PSC' stands for 'Packet Switching Capability')."; + leaf minimum-lsp-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Minimum LSP bandwidth."; + } + leaf mtu { + type uint16; + units "bytes"; + description + "Interface MTU."; + } + } + } + } + + grouping neighbor-extended-te-extensions { + description + "Grouping for TE attributes of a neighbor as defined + in RFC 8570."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + container unidirectional-link-delay { + description + "Container for the average delay + from the local neighbor to the remote neighbor."; + container flags { + leaf-list unidirectional-link-delay-subtlv-flags { + type identityref { + base unidirectional-link-delay-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Unidirectional Link Delay sub-TLV flags."; + } + leaf value { + type uint32; + units "usec"; + description + "Delay value expressed in microseconds."; + } + } + container min-max-unidirectional-link-delay { + description + "Container for the minimum and maximum delay + from the local neighbor to the remote neighbor."; + container flags { + leaf-list min-max-unidirectional-link-delay-subtlv-flags { + type identityref { + base min-max-unidirectional-link-delay-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Min/Max Unidirectional Link Delay sub-TLV flags."; + } + leaf min-value { + type uint32; + units "usec"; + description + "Minimum delay value expressed in microseconds."; + } + leaf max-value { + type uint32; + units "usec"; + description + "Maximum delay value expressed in microseconds."; + } + } + container unidirectional-link-delay-variation { + description + "Container for the average delay variation + from the local neighbor to the remote neighbor."; + leaf value { + type uint32; + units "usec"; + description + "Delay variation value expressed in microseconds."; + } + } + container unidirectional-link-loss { + description + "Container for packet loss from the local neighbor to the + remote neighbor."; + container flags { + leaf-list unidirectional-link-loss-subtlv-flags { + type identityref { + base unidirectional-link-loss-subtlv-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Unidirectional Link Loss sub-TLV flags."; + } + leaf value { + type uint32; + units "percent"; + description + "Link packet loss expressed as a percentage of + the total traffic sent over a configurable interval."; + } + } + container unidirectional-link-residual-bandwidth { + description + "Container for the residual bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Residual bandwidth."; + } + } + container unidirectional-link-available-bandwidth { + description + "Container for the available bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Available bandwidth."; + } + } + container unidirectional-link-utilized-bandwidth { + description + "Container for the utilized bandwidth + from the local neighbor to the remote neighbor."; + leaf value { + type rt-types:bandwidth-ieee-float32; + units "Bps"; + description + "Utilized bandwidth."; + } + } + } + + grouping neighbor-te-extensions { + description + "Grouping for TE attributes of a neighbor as defined + in RFC 5305."; + reference + "RFC 5305: IS-IS Extensions for Traffic Engineering"; + leaf admin-group { + type uint32; + description + "Administrative Group / Resource Class/Color."; + } + container local-if-ipv4-addrs { + description + "All local interface IPv4 addresses."; + leaf-list local-if-ipv4-addr { + type inet:ipv4-address; + description + "List of local interface IPv4 addresses."; + } + } + container remote-if-ipv4-addrs { + description + "All remote interface IPv4 addresses."; + leaf-list remote-if-ipv4-addr { + type inet:ipv4-address; + description + "List of remote interface IPv4 addresses."; + } + } + leaf te-metric { + type uint32; + description + "TE metric."; + } + leaf max-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum bandwidth."; + } + leaf max-reservable-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Maximum reservable bandwidth."; + } + container unreserved-bandwidths { + description + "All unreserved bandwidths."; + list unreserved-bandwidth { + leaf priority { + type uint8 { + range "0 .. 7"; + } + description + "Priority from 0 to 7."; + } + leaf unreserved-bandwidth { + type rt-types:bandwidth-ieee-float32; + description + "Unreserved bandwidth."; + } + description + "List of unreserved bandwidths for different + priorities."; + } + } + } + + grouping neighbor-extended { + description + "Grouping for attributes of an IS-IS extended neighbor."; + leaf neighbor-id { + type extended-system-id; + description + "System ID of the extended neighbor."; + } + container instances { + description + "List of all adjacencies between the local + system and the neighbor system ID."; + list instance { + key "id"; + leaf id { + type uint32; + description + "Unique identifier of an instance of a + particular neighbor."; + } + leaf metric { + type wide-metric; + description + "IS-IS wide metric for the extended neighbor."; + } + uses neighbor-gmpls-extensions; + uses neighbor-te-extensions; + uses neighbor-extended-te-extensions; + uses neighbor-link-attributes; + uses unknown-tlvs; + description + "Instance of a particular adjacency."; + } + } + } + + grouping neighbor { + description + "IS-IS standard neighbor grouping."; + leaf neighbor-id { + type extended-system-id; + description + "IS-IS neighbor system ID."; + } + container instances { + description + "List of all adjacencies between the local + system and the neighbor system ID."; + list instance { + key "id"; + leaf id { + type uint32; + description + "Unique identifier of an instance of a + particular neighbor."; + } + leaf i-e { + type boolean; + description + "Internal or external (I/E) metric bit value. + Set to 'false' to indicate an internal metric."; + } + container default-metric { + leaf metric { + type std-metric; + description + "IS-IS default metric value."; + } + description + "IS-IS default metric container."; + } + container delay-metric { + leaf metric { + type std-metric; + description + "IS-IS delay metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS delay metric supported."; + } + description + "IS-IS delay metric container."; + } + container expense-metric { + leaf metric { + type std-metric; + description + "IS-IS expense metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS expense metric supported."; + } + description + "IS-IS expense metric container."; + } + container error-metric { + leaf metric { + type std-metric; + description + "IS-IS error metric value."; + } + leaf supported { + type boolean; + default "false"; + description + "IS-IS error metric supported."; + } + description + "IS-IS error metric container."; + } + description + "Instance of a particular adjacency as defined in + ISO 10589."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + } + } + + /* Top-level TLVs */ + + grouping tlv132-ipv4-addresses { + leaf-list ipv4-addresses { + type inet:ipv4-address; + description + "List of IPv4 addresses of the IS-IS node. The IS-IS + reference is TLV 132."; + } + description + "Grouping for TLV 132."; + } + + grouping tlv232-ipv6-addresses { + leaf-list ipv6-addresses { + type inet:ipv6-address; + description + "List of IPv6 addresses of the IS-IS node. The IS-IS + reference is TLV 232."; + } + description + "Grouping for TLV 232."; + } + + grouping tlv134-ipv4-te-rid { + leaf ipv4-te-routerid { + type inet:ipv4-address; + description + "IPv4 Traffic Engineering router ID of the IS-IS node. + The IS-IS reference is TLV 134."; + } + description + "Grouping for TLV 134."; + } + + grouping tlv140-ipv6-te-rid { + leaf ipv6-te-routerid { + type inet:ipv6-address; + description + "IPv6 Traffic Engineering router ID of the IS-IS node. + The IS-IS reference is TLV 140."; + } + description + "Grouping for TLV 140."; + } + + grouping tlv129-protocols { + leaf-list protocol-supported { + type uint8; + description + "List of supported protocols of the IS-IS node. + The IS-IS reference is TLV 129."; + } + description + "Grouping for TLV 129."; + } + + grouping tlv137-hostname { + leaf dynamic-hostname { + type string; + description + "Hostname of the IS-IS node. The IS-IS reference + is TLV 137."; + } + description + "Grouping for TLV 137."; + } + + grouping tlv10-authentication { + container authentication { + leaf authentication-type { + type identityref { + base key-chain:crypto-algorithm; + } + description + "Authentication type to be used with an IS-IS node."; + } + leaf authentication-key { + type string; + description + "Authentication key to be used. For security reasons, + the authentication key MUST NOT be presented in + a cleartext format in response to any request + (e.g., via get or get-config)."; + } + description + "IS-IS node authentication information container. The + IS-IS reference is TLV 10."; + } + description + "Grouping for TLV 10."; + } + + grouping tlv229-mt { + container mt-entries { + list topology { + description + "List of topologies supported."; + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "Multi-Topology (MT) identifier of the topology."; + } + container attributes { + leaf-list flags { + type identityref { + base tlv229-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "TLV 229 flags."; + } + } + description + "IS-IS node topology information container. The + IS-IS reference is TLV 229."; + } + description + "Grouping for TLV 229."; + } + + grouping tlv242-router-capabilities { + container router-capabilities { + list router-capability { + container flags { + leaf-list router-capability-flags { + type identityref { + base router-capability-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "Router Capability flags."; + } + container node-tags { + if-feature "node-tag"; + list node-tag { + leaf tag { + type uint32; + description + "Node tag value."; + } + description + "List of tags."; + } + description + "Container for node administrative tags."; + } + uses unknown-tlvs; + description + "IS-IS node capabilities. This list element may + be extended with detailed information. The IS-IS + reference is TLV 242."; + } + description + "List of Router Capability TLVs."; + } + description + "Grouping for TLV 242."; + } + + grouping tlv138-srlg { + description + "Grouping for TLV 138."; + container links-srlgs { + list links { + leaf neighbor-id { + type extended-system-id; + description + "System ID of the extended neighbor."; + } + leaf flags { + type uint8; + description + "Flags associated with the link."; + } + leaf link-local-id { + type union { + type inet:ip-address; + type uint32; + } + description + "Local identifier of the link. + It could be an IPv4 address or a local identifier."; + } + leaf link-remote-id { + type union { + type inet:ip-address; + type uint32; + } + description + "Remote identifier of the link. + It could be an IPv4 address or a remotely learned + identifier."; + } + container srlgs { + description + "List of SRLGs."; + leaf-list srlg { + type uint32; + description + "SRLG value of the link."; + } + } + description + "SRLG attribute of a link."; + } + description + "List of links with SRLGs."; + } + } + + /* Grouping for LSDB descriptions */ + + grouping lsp-entry { + description + "IS-IS LSP database entry grouping."; + leaf decoded-completed { + type boolean; + description + "The IS-IS LSP body has been fully decoded."; + } + leaf raw-data { + type yang:hex-string; + description + "The hexadecimal representation of the complete LSP + as received or originated, in network byte order."; + } + leaf lsp-id { + type lsp-id; + description + "LSP ID of the LSP."; + } + leaf checksum { + type uint16; + description + "LSP checksum."; + } + leaf remaining-lifetime { + type uint16; + units "seconds"; + description + "Remaining lifetime (in seconds) until LSP expiration."; + } + leaf sequence { + type uint32; + description + "This leaf describes the sequence number of the LSP."; + } + container attributes { + leaf-list lsp-flags { + type identityref { + base lsp-flag; + } + description + "This list contains identities for the bits that + are set."; + } + description + "LSP attributes."; + } + uses tlv132-ipv4-addresses; + uses tlv232-ipv6-addresses; + uses tlv134-ipv4-te-rid; + uses tlv140-ipv6-te-rid; + uses tlv129-protocols; + uses tlv137-hostname; + uses tlv10-authentication; + uses tlv229-mt; + uses tlv242-router-capabilities; + uses tlv138-srlg; + uses unknown-tlvs; + container is-neighbor { + list neighbor { + key "neighbor-id"; + uses neighbor; + description + "List of neighbors."; + } + description + "Standard IS neighbors container. The IS-IS reference is + TLV 2."; + } + container extended-is-neighbor { + list neighbor { + key "neighbor-id"; + uses neighbor-extended; + description + "List of extended IS neighbors."; + } + description + "Standard IS extended neighbors container. The IS-IS + reference is TLV 22."; + } + container ipv4-internal-reachability { + list prefixes { + uses prefix-ipv4-std; + description + "List of prefixes."; + } + description + "IPv4 internal reachability information container. + The IS-IS reference is TLV 128."; + } + container ipv4-external-reachability { + list prefixes { + uses prefix-ipv4-std; + description + "List of prefixes."; + } + description + "IPv4 external reachability information container. The + IS-IS reference is TLV 130."; + } + container extended-ipv4-reachability { + list prefixes { + uses prefix-ipv4-extended; + uses unknown-tlvs; + description + "List of prefixes."; + } + description + "IPv4 extended reachability information container. The + IS-IS reference is TLV 135."; + } + container mt-is-neighbor { + list neighbor { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "Multi-Topology (MT) identifier."; + } + uses neighbor-extended; + description + "List of neighbors."; + } + description + "IS-IS MT neighbor container. The IS-IS reference is + TLV 223."; + } + container mt-extended-ipv4-reachability { + list prefixes { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "MT identifier."; + } + uses prefix-ipv4-extended; + uses unknown-tlvs; + description + "List of extended prefixes."; + } + description + "IPv4 MT extended reachability information container. + The IS-IS reference is TLV 235."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + container mt-ipv6-reachability { + list prefixes { + leaf mt-id { + type uint16 { + range "0 .. 4095"; + } + description + "MT identifier."; + } + uses prefix-ipv6-extended; + uses unknown-tlvs; + description + "List of IPv6 extended prefixes."; + } + description + "IPv6 MT extended reachability information container. + The IS-IS reference is TLV 237."; + reference + "RFC 5120: M-ISIS: Multi Topology (MT) Routing in + Intermediate System to Intermediate Systems (IS-ISs)"; + } + container ipv6-reachability { + list prefixes { + uses prefix-ipv6-extended; + uses unknown-tlvs; + description + "List of IPv6 prefixes."; + } + description + "IPv6 reachability information container. The IS-IS + reference is TLV 236."; + } + } + + grouping lsdb { + description + "Link State Database (LSDB) grouping."; + container database { + config false; + list levels { + key "level"; + leaf level { + type level-number; + description + "LSDB level number (1 or 2)."; + } + list lsp { + key "lsp-id"; + uses lsp-entry; + description + "List of LSPs in the LSDB."; + } + description + "List of LSPs for the LSDB-level container."; + } + description + "IS-IS LSDB container."; + } + } + + /* Augmentations */ + + augment "/rt:routing/" + + "rt:ribs/rt:rib/rt:routes/rt:route" { + when "derived-from-or-self(rt:source-protocol, 'isis:isis')" { + description + "IS-IS-specific route attributes."; + } + uses route-content; + description + "This augments the route object in the Routing Information + Base (RIB) with IS-IS-specific attributes."; + } + + augment "/if:interfaces/if:interface" { + leaf clns-mtu { + if-feature "osi-interface"; + type uint16; + description + "Connectionless-mode Network Service (CLNS) MTU of the + interface."; + } + description + "ISO-specific interface parameters."; + } + + augment "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol" { + when "derived-from-or-self(rt:type, 'isis:isis')" { + description + "This augmentation is only valid when the routing protocol + instance type is 'isis'."; + } + description + "This augments a routing protocol instance with IS-IS-specific + parameters."; + container isis { + must 'count(area-address) > 0' { + error-message "At least one area address must be " + + "configured."; + description + "Enforces the configuration of at least one area."; + } + uses instance-config; + uses instance-state; + container topologies { + if-feature "multi-topology"; + list topology { + key "name"; + leaf enabled { + type boolean; + description + "Enables the topology configuration."; + } + leaf name { + type leafref { + path "../../../../../../rt:ribs/rt:rib/rt:name"; + } + description + "RIB corresponding to the topology."; + } + uses multi-topology-config; + description + "List of topologies."; + } + description + "MT container."; + } + container interfaces { + list interface { + key "name"; + leaf name { + type if:interface-ref; + description + "Reference to the interface within + the routing instance."; + } + uses interface-config; + uses interface-state; + container topologies { + if-feature "multi-topology"; + list topology { + key "name"; + leaf name { + type leafref { + path "../../../../../../../../" + + "rt:ribs/rt:rib/rt:name"; + } + description + "RIB corresponding to the topology."; + } + uses multi-topology-interface-config; + description + "List of interface topologies."; + } + description + "MT container."; + } + description + "List of IS-IS interfaces."; + } + description + "Configuration container specific to IS-IS interfaces."; + } + description + "IS-IS configuration/state top-level container."; + } + } + + /* RPC methods */ + + rpc clear-adjacency { + description + "This RPC request clears a particular set of IS-IS + adjacencies. If the operation fails for an internal + reason, then the 'error-tag' and 'error-app-tag' should be + set indicating the reason for the failure."; + reference + "RFC 6241: Network Configuration Protocol (NETCONF)"; + input { + leaf routing-protocol-instance-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + mandatory true; + description + "Name of the IS-IS protocol instance whose IS-IS + adjacency is being cleared. + + If the corresponding IS-IS instance doesn't exist, + then the operation will fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'routing-protocol-instance-not-found'."; + } + leaf level { + type level; + description + "IS-IS level of the adjacency to be cleared. If the + IS-IS level is 'level-all', level-1 and level-2 + adjacencies would both be cleared. + + If the value provided is different from the value + authorized in the enum type, then the operation + SHALL fail with an 'error-tag' of 'data-missing' and + an 'error-app-tag' of 'bad-isis-level'."; + } + leaf interface { + type if:interface-ref; + description + "IS-IS interface name. + + If the corresponding IS-IS interface doesn't exist, + then the operation SHALL fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'isis-interface-not-found'."; + } + } + } + + rpc clear-database { + description + "This RPC request clears a particular IS-IS database. + Additionally, all neighbor adjacencies will be forced to + the DOWN state and self-originated LSPs will be + reoriginated. If the operation fails for an IS-IS + internal reason, then the 'error-tag' and 'error-app-tag' + should be set indicating the reason for the failure."; + input { + leaf routing-protocol-instance-name { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + mandatory true; + description + "Name of the IS-IS protocol instance whose IS-IS + database or databases are being cleared. + + If the corresponding IS-IS instance doesn't exist, + then the operation will fail with an 'error-tag' of + 'data-missing' and an 'error-app-tag' of + 'routing-protocol-instance-not-found'."; + } + leaf level { + type level; + description + "IS-IS level of the adjacency to be cleared. If the + IS-IS level is 'level-all', the databases for both + level 1 and level 2 would be cleared. + + If the value provided is different from the value + authorized in the enum type, then the operation + SHALL fail with an 'error-tag' of 'data-missing' and + an 'error-app-tag' of 'bad-isis-level'."; + } + } + } + + /* Notifications */ + + notification database-overload { + uses notification-instance-hdr; + leaf overload { + type enumeration { + enum off { + description + "Indicates that the IS-IS instance has left the + overload state."; + } + enum on { + description + "Indicates that the IS-IS instance has entered the + overload state."; + } + } + description + "New overload state of the IS-IS instance."; + } + description + "This notification is sent when an IS-IS instance + overload state changes."; + } + + notification lsp-too-large { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf pdu-size { + type uint32; + description + "Size of the LSP PDU."; + } + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when an attempt to propagate + an LSP that is larger than the dataLinkBlockSize (ISO 10589) + for the circuit occurs. The generation of the notification + must be throttled with at least 5 seconds between successive + notifications."; + reference + "ISO 10589: Intermediate System to Intermediate System + intra-domain routeing information exchange protocol + for use in conjunction with the protocol for providing + the connectionless-mode network service (ISO 8473)"; + } + + notification if-state-change { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf state { + type if-state-type; + description + "Interface state."; + } + description + "This notification is sent when an interface + state change is detected."; + } + + notification corrupted-lsp-detected { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when an LSP that was stored in + memory has become corrupted."; + } + + notification attempt-to-exceed-max-sequence { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system + wraps the 32-bit sequence counter of an LSP."; + } + + notification id-len-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf pdu-field-len { + type uint8; + description + "Value for the system ID length in the received PDU."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when a PDU with a different value + for the system ID length is received. The generation of the + notification must be throttled with at least 5 seconds + between successive notifications."; + } + + notification max-area-addresses-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf max-area-addresses { + type uint8; + description + "Received number of supported areas."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when a PDU with a different value + for the Maximum Area Addresses has been received. The + generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } + + notification own-lsp-purge { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system receives + a PDU with its own system ID and zero age."; + } + + notification sequence-number-skipped { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + description + "This notification is sent when the system receives a + PDU with its own system ID and different contents. The + system has to originate the LSP with a higher sequence + number."; + } + + notification authentication-type-failure { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + PDU with the wrong authentication type field. + The generation of the notification must be throttled + with at least 5 seconds between successive notifications."; + } + + notification authentication-failure { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives + a PDU on which authentication fails. The generation of the + notification must be throttled with at least 5 seconds + between successive notifications."; + } + + notification version-skew { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf protocol-version { + type uint8; + description + "Protocol version received in the PDU."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + PDU with a different protocol version number. + The generation of the notification must be throttled + with at least 5 seconds between successive notifications."; + } + + notification area-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + description + "This notification is sent when the system receives a + Hello PDU from an IS that does not share any area + address. The generation of the notification must be + throttled with at least 5 seconds between successive + notifications."; + } + + notification rejected-adjacency { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf reason { + type string { + length "0..255"; + } + description + "The system may provide a reason to reject the + adjacency. If the reason is not available, + the reason string will not be returned. + The expected format is a single line of text."; + } + description + "This notification is sent when the system receives a + Hello PDU from an IS but does not establish an adjacency + for some reason. The generation of the notification + must be throttled with at least 5 seconds between + successive notifications."; + } + + notification protocols-supported-mismatch { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf-list protocols { + type uint8; + description + "List of protocols supported by the remote system."; + } + description + "This notification is sent when the system receives a + non-pseudonode LSP that has no matching protocols + supported. The generation of the notification must be + throttled with at least 5 seconds between successive + notifications."; + } + + notification lsp-error-detected { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf raw-pdu { + type binary; + description + "Received raw PDU."; + } + leaf error-offset { + type uint32; + description + "If the problem is a malformed TLV, the error offset + points to the start of the TLV. If the problem is with + the LSP header, the error offset points to the errant + byte."; + } + leaf tlv-type { + type uint8; + description + "If the problem is a malformed TLV, the TLV type is set + to the type value of the suspicious TLV. Otherwise, + this leaf is not present."; + } + description + "This notification is sent when the system receives an + LSP with a parse error. The generation of the notification + must be throttled with at least 5 seconds between + successive notifications."; + } + + notification adjacency-state-change { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf neighbor { + type string { + length "1..255"; + } + description + "Name of the neighbor. It corresponds to the hostname + associated with the system ID of the neighbor in the + mapping database (RFC 5301). If the name of the neighbor + is not available, it is not returned."; + reference + "RFC 5301: Dynamic Hostname Exchange Mechanism for IS-IS"; + } + leaf neighbor-system-id { + type system-id; + description + "Neighbor system ID."; + } + leaf state { + type adj-state-type; + description + "New state of the IS-IS adjacency."; + } + leaf reason { + type string { + length "1..255"; + } + description + "If the adjacency is going to the 'down' state, this leaf + provides a reason for the adjacency going down. The reason + is provided as text. If the adjacency is going to the 'up' + state, no reason is provided. The expected format is a + single line of text."; + } + description + "This notification is sent when an IS-IS adjacency + moves to the 'up' state or the 'down' state."; + } + + notification lsp-received { + uses notification-instance-hdr; + uses notification-interface-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf sequence { + type uint32; + description + "Sequence number of the received LSP."; + } + leaf received-timestamp { + type yang:timestamp; + description + "Timestamp when the LSP was received."; + } + leaf neighbor-system-id { + type system-id; + description + "Neighbor system ID of the LSP sender."; + } + description + "This notification is sent when an LSP is received. + The generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } + + notification lsp-generation { + uses notification-instance-hdr; + leaf lsp-id { + type lsp-id; + description + "LSP ID."; + } + leaf sequence { + type uint32; + description + "Sequence number of the received LSP."; + } + leaf send-timestamp { + type yang:timestamp; + description + "Timestamp when the LSP was regenerated."; + } + description + "This notification is sent when an LSP is regenerated. + The generation of the notification must be throttled with + at least 5 seconds between successive notifications."; + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-l3-isis-topology.yang b/src/nbi/service/ietf_network/yang/ietf-l3-isis-topology.yang new file mode 100644 index 0000000000000000000000000000000000000000..9a5be845b2cba40f8a945bcd9feb6ddb090ba79f --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-l3-isis-topology.yang @@ -0,0 +1,53 @@ +module ietf-l3-isis-topology { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-l3-isis-topology"; + prefix isis-topology; + + import ietf-network { + prefix nw; + } + import ietf-l3-unicast-topology { + prefix l3t; + } + import ietf-inet-types { + prefix inet; + } + + organization + "TeraFlowSDN"; + contact + "TFS"; + description + "IS-IS Topology extensions matching user requirements."; + + revision 2025-02-19 { + description + "Initial revision."; + } + + augment "/nw:networks/nw:network/nw:network-types" { + container isis-topology { + presence "Indicates IS-IS topology"; + } + } + + augment "/nw:networks/nw:network/nw:node/l3t:l3-node-attributes" { + container isis-node-attributes { + leaf node-name { + type string; + } + leaf-list router-id { + type inet:ip-address; + } + leaf-list area-address { + type string; + } + leaf system-id { + type string; + } + leaf level { + type uint8; + } + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-l3-te-topology@2024-07-08.yang b/src/nbi/service/ietf_network/yang/ietf-l3-te-topology@2024-07-08.yang new file mode 100644 index 0000000000000000000000000000000000000000..4e7ffab82e0df707f2032035195db7dde607cb6b --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-l3-te-topology@2024-07-08.yang @@ -0,0 +1,126 @@ +module ietf-l3-te-topology { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-l3-te-topology"; + prefix "l3tet"; + + import ietf-network { + prefix "nw"; + reference "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-network-topology { + prefix "nt"; + reference "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-l3-unicast-topology { + prefix "l3t"; + reference "RFC 8346: A YANG Data Model for Layer 3 Topologies"; + } + + import ietf-te-topology { + prefix "tet"; + reference "RFC 8795: YANG Data Model for Traffic Engineering (TE) Topologies"; + } + + organization "IETF Traffic Engineering Architecture and Signaling (TEAS) Working Group"; + contact "WG Web: WG List: Editor: Xufeng Liu Editor: Igor Bryskin Editor: Vishnu Pavan Beeram Editor: Tarek Saad Editor: Himanshu Shah Editor: Oscar Gonzalez De Dios "; + description "YANG data model for representing and manipulating Layer 3 TE Topologies. Copyright (c) 2024 IETF Trust and the persons identified as authors of the code. All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to the license terms contained in, the Revised BSD License set forth in Section 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info). This version of this YANG module is part of RFC XXXX (https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself for full legal notices."; + revision 2024-06-08 { + description "Initial revision"; + reference "RFC XXXX: YANG Data Model for Layer 3 TE Topologies"; + } + + grouping l3-te-topology-type { + description "Identifies the L3 TE topology type."; + container l3-te { + presence "Indicates L3 TE Topology"; + description "Its presence identifies the L3 TE topology type."; + } + } + + augment "/nw:networks/nw:network/nw:network-types/" + "l3t:l3-unicast-topology" { + description "Defines the L3 TE topology type."; + uses l3-te-topology-type; + } + + augment "/nw:networks/nw:network/l3t:l3-topology-attributes" { + when "../nw:network-types/l3t:l3-unicast-topology/l3tet:l3-te" { + description "Augment only for L3 TE topology"; + } + description "Augment topology configuration"; + uses l3-te-topology-attributes; + } + + augment "/nw:networks/nw:network/nw:node/l3t:l3-node-attributes" { + when "../../nw:network-types/l3t:l3-unicast-topology/" + "l3tet:l3-te" { + description "Augment only for L3 TE topology"; + } + description "Augment node configuration"; + uses l3-te-node-attributes; + } + + augment "/nw:networks/nw:network/nw:node/nt:termination-point/" + "l3t:l3-termination-point-attributes" { + when "../../../nw:network-types/l3t:l3-unicast-topology/" + "l3tet:l3-te" { + description "Augment only for L3 TE topology"; + } + description "Augment termination point configuration"; + uses l3-te-tp-attributes; + } + + augment "/nw:networks/nw:network/nt:link/l3t:l3-link-attributes" { + when "../../nw:network-types/l3t:l3-unicast-topology/" + "l3tet:l3-te" { + description "Augment only for L3 TE topology"; + } + description "Augment link configuration"; + uses l3-te-link-attributes; + } + + grouping l3-te-topology-attributes { + description "L3 TE topology scope attributes"; + container l3-te-topology-attributes { + must "/nw:networks/nw:network" + "[nw:network-id = current()/network-ref]/" + "nw:network-types/tet:te-topology" { + error-message "The referenced network must be a TE topology."; + description "The referenced network must be a TE topology."; + } + description "Containing TE topology references"; + uses nw:network-ref; + } + } + + grouping l3-te-node-attributes { + description "L3 TE node scope attributes"; + container l3-te-node-attributes { + must "/nw:networks/nw:network" + "[nw:network-id = current()/network-ref]/" + "nw:network-types/tet:te-topology" { + error-message "The referenced network must be a TE topology."; + description "The referenced network must be a TE topology."; + } + description "Containing TE node references"; + uses nw:node-ref; + } + } + + grouping l3-te-tp-attributes { + description "L3 TE termination point scope attributes"; + container l3-te-tp-attributes { + must "/nw:networks/nw:network" + "[nw:network-id = current()/network-ref]/" + "nw:network-types/tet:te-topology" { + error-message "The referenced network must be a TE topology."; + description "The referenced network must be a TE topology."; + } + description "Containing TE termination point references"; + uses nt:tp-ref; + } + } + + grouping l3-te-link-attributes { + description "L3 TE link scope attributes"; + container l3-te-link-attributes { + must "/nw:networks/nw:network" + "[nw:network-id = current()/network-ref]/" + "nw:network-types/tet:te-topology" { + error-message "The referenced network must be a TE topology."; + description "The referenced network must be a TE topology."; + } + description "Containing TE link references"; + uses nt:link-ref; + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-routing@2018-03-13.yang b/src/nbi/service/ietf_network/yang/ietf-routing@2018-03-13.yang new file mode 100644 index 0000000000000000000000000000000000000000..9e259f0e6a7ed2648d6a335b9287ee97fceadc4c --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-routing@2018-03-13.yang @@ -0,0 +1,684 @@ +module ietf-routing { + yang-version "1.1"; + namespace "urn:ietf:params:xml:ns:yang:ietf-routing"; + prefix "rt"; + + import ietf-yang-types { + prefix "yang"; + } + + import ietf-interfaces { + prefix "if"; + description + "An 'ietf-interfaces' module version that is compatible with + the Network Management Datastore Architecture (NMDA) + is required."; + } + + organization + "IETF NETMOD (Network Modeling) Working Group"; + contact + "WG Web: + WG List: + + Editor: Ladislav Lhotka + + Acee Lindem + + Yingzhen Qu + "; + + description + "This YANG module defines essential components for the management + of a routing subsystem. The model fully conforms to the Network + Management Datastore Architecture (NMDA). + + Copyright (c) 2018 IETF Trust and the persons + identified as authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + This version of this YANG module is part of RFC 8349; see + the RFC itself for full legal notices."; + + revision 2018-03-13 { + description + "Network Management Datastore Architecture (NMDA) revision."; + reference + "RFC 8349: A YANG Data Model for Routing Management + (NMDA Version)"; + } + + revision 2016-11-04 { + description + "Initial revision."; + reference + "RFC 8022: A YANG Data Model for Routing Management"; + } + + /* Features */ + feature multiple-ribs { + description + "This feature indicates that the server supports + user-defined RIBs. + + Servers that do not advertise this feature SHOULD provide + exactly one system-controlled RIB per supported address family + and also make it the default RIB. This RIB then appears as an + entry in the list '/routing/ribs/rib'."; + } + + feature router-id { + description + "This feature indicates that the server supports an explicit + 32-bit router ID that is used by some routing protocols. + + Servers that do not advertise this feature set a router ID + algorithmically, usually to one of the configured IPv4 + addresses. However, this algorithm is implementation + specific."; + } + + /* Identities */ + + identity address-family { + description + "Base identity from which identities describing address + families are derived."; + } + identity ipv4 { + base address-family; + description + "This identity represents an IPv4 address family."; + } + + identity ipv6 { + base address-family; + description + "This identity represents an IPv6 address family."; + } + + identity control-plane-protocol { + description + "Base identity from which control-plane protocol identities are + derived."; + } + + identity routing-protocol { + base control-plane-protocol; + description + "Identity from which Layer 3 routing protocol identities are + derived."; + } + + identity direct { + base routing-protocol; + description + "Routing pseudo-protocol that provides routes to directly + connected networks."; + } + + identity static { + base routing-protocol; + description + "'Static' routing pseudo-protocol."; + } + + /* Type Definitions */ + + typedef route-preference { + type uint32; + description + "This type is used for route preferences."; + } + + /* Groupings */ + + grouping address-family { + description + "This grouping provides a leaf identifying an address + family."; + leaf address-family { + type identityref { + base address-family; + } + mandatory true; + description + "Address family."; + } + } + + grouping router-id { + description + "This grouping provides a router ID."; + leaf router-id { + type yang:dotted-quad; + description + "A 32-bit number in the form of a dotted quad that is used by + some routing protocols identifying a router."; + reference + "RFC 2328: OSPF Version 2"; + } + } + + grouping special-next-hop { + description + "This grouping provides a leaf with an enumeration of special + next hops."; + leaf special-next-hop { + type enumeration { + enum blackhole { + description + "Silently discard the packet."; + } + enum unreachable { + description + "Discard the packet and notify the sender with an error + message indicating that the destination host is + unreachable."; + } + enum prohibit { + description + "Discard the packet and notify the sender with an error + message indicating that the communication is + administratively prohibited."; + } + enum receive { + description + "The packet will be received by the local system."; + } + } + description + "Options for special next hops."; + } + } + + grouping next-hop-content { + description + "Generic parameters of next hops in static routes."; + choice next-hop-options { + mandatory true; + description + "Options for next hops in static routes. + + It is expected that further cases will be added through + augments from other modules."; + case simple-next-hop { + description + "This case represents a simple next hop consisting of the + next-hop address and/or outgoing interface. + + Modules for address families MUST augment this case with a + leaf containing a next-hop address of that address + family."; + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + } + case special-next-hop { + uses special-next-hop; + } + case next-hop-list { + container next-hop-list { + description + "Container for multiple next hops."; + list next-hop { + key "index"; + description + "An entry in a next-hop list. + + Modules for address families MUST augment this list + with a leaf containing a next-hop address of that + address family."; + leaf index { + type string; + description + "A user-specified identifier utilized to uniquely + reference the next-hop entry in the next-hop list. + The value of this index has no semantic meaning + other than for referencing the entry."; + } + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + } + } + } + } + } + + grouping next-hop-state-content { + description + "Generic state parameters of next hops."; + choice next-hop-options { + mandatory true; + description + "Options for next hops. + + It is expected that further cases will be added through + augments from other modules, e.g., for recursive + next hops."; + case simple-next-hop { + description + "This case represents a simple next hop consisting of the + next-hop address and/or outgoing interface. + + Modules for address families MUST augment this case with a + leaf containing a next-hop address of that address + family."; + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + } + case special-next-hop { + uses special-next-hop; + } + case next-hop-list { + container next-hop-list { + description + "Container for multiple next hops."; + list next-hop { + description + "An entry in a next-hop list. + + Modules for address families MUST augment this list + with a leaf containing a next-hop address of that + address family."; + leaf outgoing-interface { + type if:interface-ref; + description + "Name of the outgoing interface."; + } + } + } + } + } + } + + grouping route-metadata { + description + "Common route metadata."; + leaf source-protocol { + type identityref { + base routing-protocol; + } + mandatory true; + description + "Type of the routing protocol from which the route + originated."; + } + leaf active { + type empty; + description + "The presence of this leaf indicates that the route is + preferred among all routes in the same RIB that have the + same destination prefix."; + } + leaf last-updated { + type yang:date-and-time; + description + "Timestamp of the last modification of the route. If the + route was never modified, it is the time when the route was + inserted into the RIB."; + } + } + + /* Data nodes */ + + container routing { + description + "Configuration parameters for the routing subsystem."; + uses router-id { + if-feature "router-id"; + description + "Support for the global router ID. Routing protocols + that use a router ID can use this parameter or override it + with another value."; + } + container interfaces { + config false; + description + "Network-layer interfaces used for routing."; + leaf-list interface { + type if:interface-ref; + description + "Each entry is a reference to the name of a configured + network-layer interface."; + } + } + container control-plane-protocols { + description + "Support for control-plane protocol instances."; + list control-plane-protocol { + key "type name"; + description + "Each entry contains a control-plane protocol instance."; + leaf type { + type identityref { + base control-plane-protocol; + } + description + "Type of the control-plane protocol -- an identity + derived from the 'control-plane-protocol' + base identity."; + } + leaf name { + type string; + description + "An arbitrary name of the control-plane protocol + instance."; + } + leaf description { + type string; + description + "Textual description of the control-plane protocol + instance."; + } + container static-routes { + when "derived-from-or-self(../type, 'rt:static')" { + description + "This container is only valid for the 'static' routing + protocol."; + } + description + "Support for the 'static' pseudo-protocol. + + Address-family-specific modules augment this node with + their lists of routes."; + } + } + } + container ribs { + description + "Support for RIBs."; + list rib { + key "name"; + description + "Each entry contains a configuration for a RIB identified + by the 'name' key. + + Entries having the same key as a system-controlled entry + in the list '/routing/ribs/rib' are used for + configuring parameters of that entry. Other entries + define additional user-controlled RIBs."; + leaf name { + type string; + description + "The name of the RIB. + + For system-controlled entries, the value of this leaf + must be the same as the name of the corresponding entry + in the operational state. + + For user-controlled entries, an arbitrary name can be + used."; + } + uses address-family { + description + "The address family of the system-controlled RIB."; + } + + leaf default-rib { + if-feature "multiple-ribs"; + type boolean; + default "true"; + config false; + description + "This flag has the value of 'true' if and only if the RIB + is the default RIB for the given address family. + + By default, control-plane protocols place their routes + in the default RIBs."; + } + container routes { + config false; + description + "Current contents of the RIB."; + list route { + description + "A RIB route entry. This data node MUST be augmented + with information specific to routes of each address + family."; + leaf route-preference { + type route-preference; + description + "This route attribute, also known as 'administrative + distance', allows for selecting the preferred route + among routes with the same destination prefix. A + smaller value indicates a route that is + more preferred."; + } + container next-hop { + description + "Route's next-hop attribute."; + uses next-hop-state-content; + } + uses route-metadata; + } + } + action active-route { + description + "Return the active RIB route that is used for the + destination address. + + Address-family-specific modules MUST augment input + parameters with a leaf named 'destination-address'."; + output { + container route { + description + "The active RIB route for the specified destination. + + If no route exists in the RIB for the destination + address, no output is returned. + + Address-family-specific modules MUST augment this + container with appropriate route contents."; + container next-hop { + description + "Route's next-hop attribute."; + uses next-hop-state-content; + } + uses route-metadata; + } + } + } + leaf description { + type string; + description + "Textual description of the RIB."; + } + } + } + } + + /* + * The subsequent data nodes are obviated and obsoleted + * by the Network Management Datastore Architecture + * as described in RFC 8342. + */ + container routing-state { + config false; + status obsolete; + description + "State data of the routing subsystem."; + uses router-id { + status obsolete; + description + "Global router ID. + + It may be either configured or assigned algorithmically by + the implementation."; + } + container interfaces { + status obsolete; + description + "Network-layer interfaces used for routing."; + leaf-list interface { + type if:interface-state-ref; + status obsolete; + description + "Each entry is a reference to the name of a configured + network-layer interface."; + } + } + container control-plane-protocols { + status obsolete; + description + "Container for the list of routing protocol instances."; + list control-plane-protocol { + key "type name"; + status obsolete; + description + "State data of a control-plane protocol instance. + + An implementation MUST provide exactly one + system-controlled instance of the 'direct' + pseudo-protocol. Instances of other control-plane + protocols MAY be created by configuration."; + leaf type { + type identityref { + base control-plane-protocol; + } + status obsolete; + description + "Type of the control-plane protocol."; + } + leaf name { + type string; + status obsolete; + description + "The name of the control-plane protocol instance. + + For system-controlled instances, this name is + persistent, i.e., it SHOULD NOT change across + reboots."; + } + } + } + container ribs { + status obsolete; + description + "Container for RIBs."; + list rib { + key "name"; + min-elements 1; + status obsolete; + description + "Each entry represents a RIB identified by the 'name' + key. All routes in a RIB MUST belong to the same address + family. + + An implementation SHOULD provide one system-controlled + default RIB for each supported address family."; + leaf name { + type string; + status obsolete; + description + "The name of the RIB."; + } + uses address-family { + status obsolete; + description + "The address family of the RIB."; + } + leaf default-rib { + if-feature "multiple-ribs"; + type boolean; + default "true"; + status obsolete; + description + "This flag has the value of 'true' if and only if the + RIB is the default RIB for the given address family. + + By default, control-plane protocols place their routes + in the default RIBs."; + } + container routes { + status obsolete; + description + "Current contents of the RIB."; + list route { + status obsolete; + description + "A RIB route entry. This data node MUST be augmented + with information specific to routes of each address + family."; + leaf route-preference { + type route-preference; + status obsolete; + description + "This route attribute, also known as 'administrative + distance', allows for selecting the preferred route + among routes with the same destination prefix. A + smaller value indicates a route that is + more preferred."; + } + container next-hop { + status obsolete; + description + "Route's next-hop attribute."; + uses next-hop-state-content { + status obsolete; + description + "Route's next-hop attribute operational state."; + } + } + uses route-metadata { + status obsolete; + description + "Route metadata."; + } + } + } + action active-route { + status obsolete; + description + "Return the active RIB route that is used for the + destination address. + + Address-family-specific modules MUST augment input + parameters with a leaf named 'destination-address'."; + output { + container route { + status obsolete; + description + "The active RIB route for the specified + destination. + + If no route exists in the RIB for the destination + address, no output is returned. + + Address-family-specific modules MUST augment this + container with appropriate route contents."; + container next-hop { + status obsolete; + description + "Route's next-hop attribute."; + uses next-hop-state-content { + status obsolete; + description + "Active route state data."; + } + } + uses route-metadata { + status obsolete; + description + "Active route metadata."; + } + } + } + } + } + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-segment-routing-common@2021-05-26.yang b/src/nbi/service/ietf_network/yang/ietf-segment-routing-common@2021-05-26.yang new file mode 100644 index 0000000000000000000000000000000000000000..84b778450669b42150fabaf3dbd613205c07e1cf --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-segment-routing-common@2021-05-26.yang @@ -0,0 +1,242 @@ +module ietf-segment-routing-common { + yang-version 1.1; + namespace + "urn:ietf:params:xml:ns:yang:ietf-segment-routing-common"; + prefix sr-cmn; + + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + + organization + "IETF SPRING - SPRING Working Group"; + contact + "WG Web: + WG List: + + Author: Stephane Litkowski + + Author: Yingzhen Qu + + Author: Acee Lindem + + Author: Pushpasis Sarkar + + Author: Jeff Tantsura + + + "; + description + "This YANG module defines a collection of generic types and + groupings for Segment Routing (SR), as described in RFC 8402. + + This YANG module conforms to the Network Management + Datastore Architecture (NMDA), as described in RFC 8242. + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2021 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 9020; + see the RFC itself for full legal notices."; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + + revision 2021-05-26 { + description + "Initial version"; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + } + + feature sid-last-hop-behavior { + description + "Configurable last-hop behavior."; + reference + "RFC 8660: Segment Routing with the MPLS Data Plane"; + } + + identity prefix-sid-algorithm { + description + "Base identity for prefix-sid algorithm."; + reference + "RFC 8402: Segment Routing Architecture"; + } + + identity prefix-sid-algorithm-shortest-path { + base prefix-sid-algorithm; + description + "Shortest Path First (SPF) Prefix-SID algorithm. This + is the default algorithm."; + } + + identity prefix-sid-algorithm-strict-spf { + base prefix-sid-algorithm; + description + "This algorithm mandates that the packet is forwarded + according to the ECMP-aware SPF algorithm."; + } + + grouping srlr { + description + "Grouping for SR Label Range configuration."; + leaf lower-bound { + type uint32; + description + "Lower value in the label range."; + } + leaf upper-bound { + type uint32; + must '../lower-bound < ../upper-bound' { + error-message + "The upper-bound must be greater than the lower-bound."; + description + "The value must be greater than lower-bound."; + } + description + "Upper value in the label range."; + } + } + + grouping srgb { + description + "Grouping for SR Global Label Range."; + list srgb { + key "lower-bound upper-bound"; + ordered-by user; + description + "List of global blocks to be advertised."; + uses srlr; + } + } + + grouping srlb { + description + "Grouping for SR Local Block Range."; + list srlb { + key "lower-bound upper-bound"; + ordered-by user; + description + "List of SRLBs."; + uses srlr; + } + } + + grouping sid-value-type { + description + "Defines how the SID value is expressed."; + leaf value-type { + type enumeration { + enum index { + description + "The value will be interpreted as an index."; + } + enum absolute { + description + "The value will become interpreted as an absolute + value."; + } + } + default "index"; + description + "This leaf defines how the value must be interpreted."; + } + } + + grouping prefix-sid { + description + "This grouping defines configuration of a Prefix-SID."; + leaf prefix { + type inet:ip-prefix; + description + "Connected Prefix-SID."; + } + uses prefix-sid-attributes; + } + + grouping ipv4-sid { + description + "Grouping for an IPv4 Prefix-SID."; + leaf prefix { + type inet:ipv4-prefix; + description + "Connected IPv4 Prefix-SID."; + } + uses prefix-sid-attributes; + } + + grouping ipv6-sid { + description + "Grouping for an IPv6 Prefix-SID."; + leaf prefix { + type inet:ipv6-prefix; + description + "Connected IPv6 Prefix-SID."; + } + uses prefix-sid-attributes; + } + + grouping last-hop-behavior { + description + "Defines last-hop behavior."; + leaf last-hop-behavior { + if-feature "sid-last-hop-behavior"; + type enumeration { + enum explicit-null { + description + "Use explicit-null for the SID."; + } + enum no-php { + description + "Do not use MPLS Penultimate Hop Popping (PHP) + for the SID."; + } + enum php { + description + "Use MPLS PHP for the SID."; + } + } + description + "Configure last-hop behavior."; + } + } + + grouping prefix-sid-attributes { + description + "Grouping for Segment Routing (SR) prefix attributes."; + uses sid-value-type; + leaf start-sid { + type uint32; + mandatory true; + description + "Value associated with prefix. The value must be + interpreted in the context of sid-value-type."; + } + leaf range { + type uint32; + description + "Indicates how many SIDs can be allocated."; + } + leaf algorithm { + type identityref { + base prefix-sid-algorithm; + } + description + "Prefix-SID algorithm."; + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-segment-routing-mpls@2021-05-26.yang b/src/nbi/service/ietf_network/yang/ietf-segment-routing-mpls@2021-05-26.yang new file mode 100644 index 0000000000000000000000000000000000000000..fa9826e6281bd4da8ad4ab3817932c02749df250 --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-segment-routing-mpls@2021-05-26.yang @@ -0,0 +1,554 @@ +module ietf-segment-routing-mpls { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-segment-routing-mpls"; + prefix sr-mpls; + + import ietf-inet-types { + prefix inet; + reference + "RFC 6991: Common YANG Data Types"; + } + import ietf-routing { + prefix rt; + reference + "RFC 8349: A YANG Data Model for Routing + Management (NMDA Version)"; + } + import ietf-routing-types { + prefix rt-types; + reference + "RFC 8294: Common YANG Data Types for the + Routing Area"; + } + import ietf-segment-routing { + prefix sr; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + } + import ietf-segment-routing-common { + prefix sr-cmn; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + } + + organization + "IETF SPRING - SPRING Working Group"; + contact + "WG Web: + WG List: + + Author: Stephane Litkowski + + Author: Yingzhen Qu + + Author: Acee Lindem + + Author: Pushpasis Sarkar + + Author: Jeff Tantsura + + + "; + description + "This YANG module defines a generic configuration model for + the Segment Routing MPLS data plane. + + This YANG module conforms to the Network Management + Datastore Architecture (NMDA), as described in RFC 8242. + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2021 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 9020; + see the RFC itself for full legal notices."; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + + revision 2021-05-26 { + description + "Initial version"; + reference + "RFC 9020: YANG Data Model for Segment Routing"; + } + + feature mapping-server { + description + "Support for Segment Routing Mapping Server (SRMS)."; + reference + "RFC 8661: Segment Routing MPLS Interworking + with LDP"; + } + + feature protocol-srgb { + description + "Support for per-protocol Segment Routing Global Block + (SRGB) configuration."; + reference + "RFC 8660: Segment Routing with the MPLS + Data Plane"; + } + + typedef system-id { + type string { + pattern '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}'; + } + description + "This type defines an IS-IS system-id using a pattern. + An example system-id is 0143.0438.AEF0."; + } + + typedef router-or-system-id { + type union { + type rt-types:router-id; + type system-id; + } + description + "OSPF/BGP router-id or IS-IS system ID."; + } + + grouping sr-control-plane { + description + "Defines protocol configuration."; + container segment-routing { + description + "Segment Routing global configuration."; + leaf enabled { + type boolean; + default "false"; + description + "Enables Segment Routing control-plane protocol + extensions."; + } + container bindings { + if-feature "mapping-server"; + description + "Control of binding advertisement and reception."; + container advertise { + description + "Control advertisement of local mappings + in binding TLVs."; + leaf-list policies { + type leafref { + path "/rt:routing/sr:segment-routing/sr-mpls:sr-mpls" + + "/sr-mpls:bindings/sr-mpls:mapping-server" + + "/sr-mpls:policy/sr-mpls:name"; + } + description + "List of binding advertisement policies."; + } + } + leaf receive { + type boolean; + default "true"; + description + "Allow the reception and usage of binding TLVs."; + } + } + } + } + + grouping igp-interface { + description + "Grouping for IGP interface configuration."; + container segment-routing { + description + "Container for SR interface configuration."; + container adjacency-sid { + description + "Adjacency SID (Adj-SID) configuration."; + reference + "RFC 8660: Segment Routing with the MPLS + Data Plane"; + list adj-sids { + key "value"; + uses sr-cmn:sid-value-type; + leaf value { + type uint32; + description + "Value of the Adj-SID."; + } + leaf protected { + type boolean; + default "false"; + description + "It is used to protect the Adj-SID, e.g., using + IP Fast Reroute (IPFRR) or MPLS-FRR."; + } + leaf weight { + type uint8; + description + "The load-balancing factor over parallel adjacencies."; + reference + "RFC 8402: Segment Routing Architecture + RFC 8665: OSPF Extensions for Segment Routing + RFC 8667: IS-IS Extensions for Segment + Routing"; + } + description + "List of Adj-SIDs and their configuration."; + } + list advertise-adj-group-sid { + key "group-id"; + description + "Control advertisement of S-flag or G-flag. Enable + advertisement of a common Adj-SID for parallel + links."; + reference + "RFC 8665: OSPF Extensions for Segment Routing, + Section 6.1 + RFC 8667: IS-IS Extensions for Segment + Routing, Section 2.2.1"; + leaf group-id { + type uint32; + description + "The value is an internal value to identify a + group-ID. Interfaces with the same group-ID + will be bundled together."; + } + } + leaf advertise-protection { + type enumeration { + enum single { + description + "A single Adj-SID is associated with the + adjacency and reflects the protection + configuration."; + } + enum dual { + description + "Two Adj-SIDs will be associated with the adjacency + if the interface is protected. In this case, one + Adj-SID will be advertised with the backup-flag + set and the other with the backup-flag clear. In + the case where protection is not configured, a + single Adj-SID will be advertised with the + backup-flag clear."; + } + } + description + "If set, the Adj-SID refers to a protected adjacency."; + reference + "RFC 8665: OSPF Extensions for Segment Routing, + Section 6.1 + RFC 8667: IS-IS Extensions for Segment + Routing, Section 2.2.1"; + } + } + } + } + + augment "/rt:routing/sr:segment-routing" { + description + "This augments the routing data model (RFC 8349) + with Segment Routing (SR) using the MPLS data plane."; + container sr-mpls { + description + "Segment Routing global configuration and + operational state."; + container bindings { + description + "List of bindings."; + container mapping-server { + if-feature "mapping-server"; + description + "Configuration of mapping-server local entries."; + list policy { + key "name"; + description + "List mapping-server policies."; + leaf name { + type string; + description + "Name of the mapping policy."; + } + container entries { + description + "IPv4/IPv6 mapping entries."; + list mapping-entry { + key "prefix algorithm"; + description + "Mapping entries."; + uses sr-cmn:prefix-sid; + } + } + } + } + container connected-prefix-sid-map { + description + "Prefix-SID configuration."; + list connected-prefix-sid { + key "prefix algorithm"; + description + "List of mappings of Prefix-SIDs to IPv4/IPv6 + local prefixes."; + uses sr-cmn:prefix-sid; + uses sr-cmn:last-hop-behavior; + } + } + container local-prefix-sid { + description + "Local SID configuration."; + list local-prefix-sid { + key "prefix algorithm"; + description + "List of local IPv4/IPv6 Prefix-SIDs."; + uses sr-cmn:prefix-sid; + } + } + } + container srgb { + description + "Global SRGB configuration."; + uses sr-cmn:srgb; + } + container srlb { + description + "Segment Routing Local Block (SRLB) configuration."; + uses sr-cmn:srlb; + } + list label-blocks { + config false; + description + "List of label blocks currently in use."; + leaf lower-bound { + type uint32; + description + "Lower bound of the label block."; + } + leaf upper-bound { + type uint32; + description + "Upper bound of the label block."; + } + leaf size { + type uint32; + description + "Number of indexes in the block."; + } + leaf free { + type uint32; + description + "Number of free indexes in the block."; + } + leaf used { + type uint32; + description + "Number of indexes in use in the block."; + } + leaf scope { + type enumeration { + enum global { + description + "Global SID."; + } + enum local { + description + "Local SID."; + } + } + description + "Scope of this label block."; + } + } + container sid-db { + config false; + description + "List of prefix and SID associations."; + list sid { + key "target sid source source-protocol binding-type"; + ordered-by system; + description + "SID binding."; + leaf target { + type string; + description + "Defines the target of the binding. It can be a + prefix or something else."; + } + leaf sid { + type uint32; + description + "Index associated with the prefix."; + } + leaf algorithm { + type uint8; + description + "Algorithm to be used for the Prefix-SID."; + reference + "RFC 8665: OSPF Extensions for Segment Routing + RFC 8667: IS-IS Extensions for Segment + Routing + RFC 8669: Segment Routing Prefix Segment + Identifier Extensions to BGP"; + } + leaf source { + type inet:ip-address; + description + "IP address of the router that owns the binding."; + } + leaf used { + type boolean; + description + "Indicates if the binding is installed in the + forwarding plane."; + } + leaf source-protocol { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Routing protocol that owns the binding."; + } + leaf binding-type { + type enumeration { + enum prefix-sid { + description + "Binding is learned from a Prefix-SID."; + } + enum binding-tlv { + description + "Binding is learned from a binding TLV."; + } + } + description + "Type of binding."; + } + leaf scope { + type enumeration { + enum global { + description + "Global SID."; + } + enum local { + description + "Local SID."; + } + } + description + "SID scoping."; + } + } + } + } + } + + notification segment-routing-srgb-collision { + description + "This notification is sent when SRGB blocks received from + different routers collide."; + list srgb-collisions { + description + "List of SRGB blocks that collide."; + leaf lower-bound { + type uint32; + description + "Lower value in the block."; + } + leaf upper-bound { + type uint32; + description + "Upper value in the block."; + } + leaf routing-protocol { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Routing protocol reference for SRGB collision."; + } + leaf originating-rtr-id { + type router-or-system-id; + description + "Originating router ID of this SRGB block."; + } + } + } + + notification segment-routing-global-sid-collision { + description + "This notification is sent when a new mapping is learned + containing a mapping where the SID is already used. + The notification generation must be throttled with at least + a 5-second gap between notifications."; + leaf received-target { + type string; + description + "Target received in the router advertisement that caused + the SID collision."; + } + leaf new-sid-rtr-id { + type router-or-system-id; + description + "Router ID that advertised the colliding SID."; + } + leaf original-target { + type string; + description + "Target already available in the database with the same SID + as the received target."; + } + leaf original-sid-rtr-id { + type router-or-system-id; + description + "Router ID for the router that originally advertised the + colliding SID, i.e., the instance in the database."; + } + leaf index { + type uint32; + description + "Value of the index used by two different prefixes."; + } + leaf routing-protocol { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Routing protocol reference for colliding SID."; + } + } + + notification segment-routing-index-out-of-range { + description + "This notification is sent when a binding is received + containing a segment index that is out of the local + configured ranges. The notification generation must be + throttled with at least a 5-second gap between + notifications."; + leaf received-target { + type string; + description + "A human-readable string representing the target + received in the protocol-specific advertisement + corresponding to the out-of-range index."; + } + leaf received-index { + type uint32; + description + "Value of the index received."; + } + leaf routing-protocol { + type leafref { + path "/rt:routing/rt:control-plane-protocols/" + + "rt:control-plane-protocol/rt:name"; + } + description + "Routing protocol reference for out-of-range indexed."; + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2020-06-10.yang b/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2020-06-10.yang deleted file mode 100644 index 8e7d4aafadcc34ec21dbf553d72852dc64624c4a..0000000000000000000000000000000000000000 --- a/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2020-06-10.yang +++ /dev/null @@ -1,475 +0,0 @@ -module ietf-te-packet-types { - yang-version 1.1; - namespace "urn:ietf:params:xml:ns:yang:ietf-te-packet-types"; - prefix te-packet-types; - - /* Import TE generic types */ - - import ietf-te-types { - prefix te-types; - reference - "RFC 8776: Common YANG Data Types for Traffic Engineering"; - } - - organization - "IETF Traffic Engineering Architecture and Signaling (TEAS) - Working Group"; - contact - "WG Web: - WG List: - - Editor: Tarek Saad - - - Editor: Rakesh Gandhi - - - Editor: Vishnu Pavan Beeram - - - Editor: Xufeng Liu - - - Editor: Igor Bryskin - "; - description - "This YANG module contains a collection of generally useful YANG - data type definitions specific to MPLS TE. The model fully - conforms to the Network Management Datastore Architecture - (NMDA). - - Copyright (c) 2020 IETF Trust and the persons identified as - authors of the code. All rights reserved. - - Redistribution and use in source and binary forms, with or - without modification, is permitted pursuant to, and subject to - the license terms contained in, the Simplified BSD License set - forth in Section 4.c of the IETF Trust's Legal Provisions - Relating to IETF Documents - (https://trustee.ietf.org/license-info). - - This version of this YANG module is part of RFC 8776; see the - RFC itself for full legal notices."; - - revision 2020-06-10 { - description - "Latest revision of TE MPLS types."; - reference - "RFC 8776: Common YANG Data Types for Traffic Engineering"; - } - - /** - * Typedefs - */ - - typedef te-bandwidth-requested-type { - type enumeration { - enum specified { - description - "Bandwidth is explicitly specified."; - } - enum auto { - description - "Bandwidth is automatically computed."; - } - } - description - "Enumerated type for specifying whether bandwidth is - explicitly specified or automatically computed."; - } - - typedef te-class-type { - type uint8; - description - "Diffserv-TE Class-Type. Defines a set of Traffic Trunks - crossing a link that is governed by a specific set of - bandwidth constraints. Class-Type is used for the purposes - of link bandwidth allocation, constraint-based routing, and - admission control."; - reference - "RFC 4124: Protocol Extensions for Support of Diffserv-aware - MPLS Traffic Engineering"; - } - - typedef bc-type { - type uint8 { - range "0..7"; - } - description - "Diffserv-TE bandwidth constraints as defined in RFC 4124."; - reference - "RFC 4124: Protocol Extensions for Support of Diffserv-aware - MPLS Traffic Engineering"; - } - - typedef bandwidth-kbps { - type uint64; - units "Kbps"; - description - "Bandwidth values, expressed in kilobits per second."; - } - - typedef bandwidth-mbps { - type uint64; - units "Mbps"; - description - "Bandwidth values, expressed in megabits per second."; - } - - typedef bandwidth-gbps { - type uint64; - units "Gbps"; - description - "Bandwidth values, expressed in gigabits per second."; - } - - identity backup-protection-type { - description - "Base identity for the backup protection type."; - } - - identity backup-protection-link { - base backup-protection-type; - description - "Backup provides link protection only."; - } - - identity backup-protection-node-link { - base backup-protection-type; - description - "Backup offers node (preferred) or link protection."; - } - - identity bc-model-type { - description - "Base identity for the Diffserv-TE Bandwidth Constraints - Model type."; - reference - "RFC 4124: Protocol Extensions for Support of Diffserv-aware - MPLS Traffic Engineering"; - } - - identity bc-model-rdm { - base bc-model-type; - description - "Russian Dolls Bandwidth Constraints Model type."; - reference - "RFC 4127: Russian Dolls Bandwidth Constraints Model for - Diffserv-aware MPLS Traffic Engineering"; - } - - identity bc-model-mam { - base bc-model-type; - description - "Maximum Allocation Bandwidth Constraints Model type."; - reference - "RFC 4125: Maximum Allocation Bandwidth Constraints Model for - Diffserv-aware MPLS Traffic Engineering"; - } - - identity bc-model-mar { - base bc-model-type; - description - "Maximum Allocation with Reservation Bandwidth Constraints - Model type."; - reference - "RFC 4126: Max Allocation with Reservation Bandwidth - Constraints Model for Diffserv-aware MPLS Traffic Engineering - & Performance Comparisons"; - } - - grouping performance-metrics-attributes-packet { - description - "Contains PM attributes."; - uses te-types:performance-metrics-attributes { - augment "performance-metrics-one-way" { - leaf one-way-min-delay { - type uint32 { - range "0..16777215"; - } - description - "One-way minimum delay or latency in microseconds."; - } - leaf one-way-min-delay-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "One-way minimum delay or latency normality."; - } - leaf one-way-max-delay { - type uint32 { - range "0..16777215"; - } - description - "One-way maximum delay or latency in microseconds."; - } - leaf one-way-max-delay-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "One-way maximum delay or latency normality."; - } - leaf one-way-delay-variation { - type uint32 { - range "0..16777215"; - } - description - "One-way delay variation in microseconds."; - reference - "RFC 5481: Packet Delay Variation Applicability - Statement, Section 4.2"; - } - leaf one-way-delay-variation-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "One-way delay variation normality."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric - Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - leaf one-way-packet-loss { - type decimal64 { - fraction-digits 6; - range "0..50.331642"; - } - description - "One-way packet loss as a percentage of the total traffic - sent over a configurable interval. The finest precision - is 0.000003%, where the maximum is 50.331642%."; - reference - "RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions, Section 4.4"; - } - leaf one-way-packet-loss-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "Packet loss normality."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric - Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - description - "PM one-way packet-specific augmentation for a generic PM - grouping."; - } - augment "performance-metrics-two-way" { - leaf two-way-min-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way minimum delay or latency in microseconds."; - } - leaf two-way-min-delay-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "Two-way minimum delay or latency normality."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric - Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - leaf two-way-max-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way maximum delay or latency in microseconds."; - } - leaf two-way-max-delay-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "Two-way maximum delay or latency normality."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric - Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - leaf two-way-delay-variation { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way delay variation in microseconds."; - reference - "RFC 5481: Packet Delay Variation Applicability - Statement, Section 4.2"; - } - leaf two-way-delay-variation-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "Two-way delay variation normality."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric - Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - leaf two-way-packet-loss { - type decimal64 { - fraction-digits 6; - range "0..50.331642"; - } - default "0"; - description - "Two-way packet loss as a percentage of the total traffic - sent over a configurable interval. The finest precision - is 0.000003%."; - } - leaf two-way-packet-loss-normality { - type te-types:performance-metrics-normality; - default "normal"; - description - "Two-way packet loss normality."; - } - description - "PM two-way packet-specific augmentation for a generic PM - grouping."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions - RFC 7823: Performance-Based Path Selection for - Explicitly Routed Label Switched Paths (LSPs) Using - TE Metric Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions"; - } - } - } - - grouping one-way-performance-metrics-packet { - description - "One-way packet PM throttle grouping."; - leaf one-way-min-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "One-way minimum delay or latency in microseconds."; - } - leaf one-way-max-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "One-way maximum delay or latency in microseconds."; - } - leaf one-way-delay-variation { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "One-way delay variation in microseconds."; - } - leaf one-way-packet-loss { - type decimal64 { - fraction-digits 6; - range "0..50.331642"; - } - default "0"; - description - "One-way packet loss as a percentage of the total traffic - sent over a configurable interval. The finest precision is - 0.000003%."; - } - } - - grouping two-way-performance-metrics-packet { - description - "Two-way packet PM throttle grouping."; - leaf two-way-min-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way minimum delay or latency in microseconds."; - } - leaf two-way-max-delay { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way maximum delay or latency in microseconds."; - } - leaf two-way-delay-variation { - type uint32 { - range "0..16777215"; - } - default "0"; - description - "Two-way delay variation in microseconds."; - } - leaf two-way-packet-loss { - type decimal64 { - fraction-digits 6; - range "0..50.331642"; - } - default "0"; - description - "Two-way packet loss as a percentage of the total traffic - sent over a configurable interval. The finest precision is - 0.000003%."; - } - } - - grouping performance-metrics-throttle-container-packet { - description - "Packet PM threshold grouping."; - uses te-types:performance-metrics-throttle-container { - augment "throttle/threshold-out" { - uses one-way-performance-metrics-packet; - uses two-way-performance-metrics-packet; - description - "PM threshold-out packet augmentation for a - generic grouping."; - } - augment "throttle/threshold-in" { - uses one-way-performance-metrics-packet; - uses two-way-performance-metrics-packet; - description - "PM threshold-in packet augmentation for a - generic grouping."; - } - augment "throttle/threshold-accelerated-advertisement" { - uses one-way-performance-metrics-packet; - uses two-way-performance-metrics-packet; - description - "PM accelerated advertisement packet augmentation for a - generic grouping."; - } - } - } -} diff --git a/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2026-01-15.yang b/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2026-01-15.yang new file mode 100644 index 0000000000000000000000000000000000000000..54393a9c33b7de86f95ef63e2a2f74b7aefc5e6c --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-te-packet-types@2026-01-15.yang @@ -0,0 +1,844 @@ +module ietf-te-packet-types { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-te-packet-types"; + prefix te-packet-types; + + import ietf-yang-types { + prefix yang; + reference + "RFC 9911: Common YANG Data Types"; + } + import ietf-te-types { + prefix te-types; + reference + "RFC XXXX: Common YANG Data Types for Traffic Engineering"; + } + + organization + "IETF Traffic Engineering Architecture and Signaling (TEAS) + Working Group"; + contact + "WG Web: + WG List: + + Editor: Tarek Saad + + + Editor: Rakesh Gandhi + + + Editor: Vishnu Pavan Beeram + + + Editor: Xufeng Liu + + + Editor: Igor Bryskin + "; + description + "This YANG module contains a collection of generally useful YANG + data type definitions specific to Packet Traffic Engineering + (TE). + + The model conforms to the Network Management Datastore + Architecture (NMDA). + + The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL + NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', + 'MAY', and 'OPTIONAL' in this document are to be interpreted as + described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, + they appear in all capitals, as shown here. + + Copyright (c) 2026 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject to + the license terms contained in, the Revised BSD License set + forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (https://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC XXXX + (https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself + for full legal notices."; + + // RFC Ed.: update the date below with the date of RFC publication + // and remove this note. + + revision 2026-01-15 { + description + "This revision adds the following new identities: + - bandwidth-profile-type; + - link-metric-delay-variation; + - link-metric-loss; + - path-metric-delay-variation; + - path-metric-loss. + + This revision adds the following new groupings: + - bandwidth-profile-parameters; + - te-packet-path-bandwidth; + - te-packet-link-bandwidth. + + This revision provides also few editorial changes."; + reference + "RFC XXXX: Common YANG Data Types for Traffic Engineering"; + } + revision 2020-06-10 { + description + "Latest revision of TE MPLS types."; + reference + "RFC 8776: Common YANG Data Types for Traffic Engineering"; + } + + /* + * Identities + */ + + identity bandwidth-profile-type { + description + "Bandwidth Profile Types"; + } + + identity mef-10 { + base bandwidth-profile-type; + description + "MEF 10 Bandwidth Profile"; + reference + "MEF 10.3: Ethernet Services Attributes Phase 3"; + } + + identity rfc-2697 { + base bandwidth-profile-type; + description + "RFC 2697 Bandwidth Profile"; + reference + "RFC 2697: A Single Rate Three Color Marker"; + } + + identity rfc-2698 { + base bandwidth-profile-type; + description + "RFC 2698 Bandwidth Profile"; + reference + "RFC 2698: A Two Rate Three Color Marker"; + } + + // Derived identities from te-types:link-metric-type + + identity link-metric-delay-variation { + base te-types:link-metric-type; + description + "The Unidirectional Delay Variation Metric, + measured in units of microseconds."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions, + Section 4.3 + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions, + Section 4.3"; + } + + identity link-metric-loss { + base te-types:link-metric-type; + description + "The Unidirectional Link Loss Metric, + measured in units of 0.000003%."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions, + Section 4.4 + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions, + Section 4.4"; + } + + // Derived identities from te-types:path-metric-type + + identity path-metric-delay-variation { + base te-types:path-metric-type; + description + "The Path Delay Variation Metric, + measured in units of microseconds."; + reference + "RFC 8233: Extensions to the Path Computation Element + Communication Protocol (PCEP) to Compute + Service-Aware Label Switched Paths (LSPs), + Section 3.1.2"; + } + + identity path-metric-loss { + base te-types:path-metric-type; + description + "The Path Loss Metric, measured in units of 0.000003%."; + reference + "RFC 8233: Extensions to the Path Computation Element + Communication Protocol (PCEP) to Compute + Service-Aware Label Switched Paths (LSPs), + Section 3.1.3"; + } + + identity backup-protection-type { + description + "Base identity for the backup protection type."; + } + + identity backup-protection-link { + base backup-protection-type; + description + "Backup provides link protection only."; + } + + identity backup-protection-node-link { + base backup-protection-type; + description + "Backup offers node (preferred) or link protection."; + } + + identity bc-model-type { + description + "Base identity for the Diffserv-TE Bandwidth Constraints + Model type."; + reference + "RFC 4124: Protocol Extensions for Support of Diffserv-aware + MPLS Traffic Engineering"; + } + + identity bc-model-rdm { + base bc-model-type; + description + "Russian Dolls Bandwidth Constraints Model type."; + reference + "RFC 4127: Russian Dolls Bandwidth Constraints Model for + Diffserv-aware MPLS Traffic Engineering"; + } + + identity bc-model-mam { + base bc-model-type; + description + "Maximum Allocation Bandwidth Constraints Model type."; + reference + "RFC 4125: Maximum Allocation Bandwidth Constraints Model for + Diffserv-aware MPLS Traffic Engineering"; + } + + identity bc-model-mar { + base bc-model-type; + description + "Maximum Allocation with Reservation Bandwidth Constraints + Model type."; + reference + "RFC 4126: Max Allocation with Reservation Bandwidth + Constraints Model for Diffserv-aware MPLS Traffic + Engineering & Performance Comparisons"; + } + + /* + * Typedefs + */ + + typedef te-bandwidth-requested-type { + type enumeration { + enum specified-value { + description + "Bandwidth value is explicitly specified."; + } + enum specified-profile { + description + "Bandwidth profile is explicitly specified."; + } + enum auto { + description + "Bandwidth is automatically computed."; + } + } + description + "Enumerated type for specifying whether bandwidth is + explicitly specified or automatically computed."; + } + + typedef te-class-type { + type uint8; + description + "Diffserv-TE Class-Type. + Defines a set of Traffic Trunks crossing a link that is + governed by a specific set of bandwidth constraints. + + Class-Type is used for the purposes of link bandwidth + allocation, constraint-based routing, and admission control."; + reference + "RFC 4124: Protocol Extensions for Support of Diffserv-aware + MPLS Traffic Engineering"; + } + + typedef bc-type { + type uint8 { + range "0..7"; + } + description + "Diffserv-TE bandwidth constraints as defined in RFC 4124."; + reference + "RFC 4124: Protocol Extensions for Support of Diffserv-aware + MPLS Traffic Engineering"; + } + + typedef bandwidth-kbps { + type uint64; + units "kilobits per second"; + description + "Bandwidth values, expressed in kilobits per second."; + } + + typedef bandwidth-mbps { + type uint64; + units "megabits per second"; + description + "Bandwidth values, expressed in megabits per second."; + } + + typedef bandwidth-gbps { + type uint64; + units "gigabits per second"; + description + "Bandwidth values, expressed in gigabits per second."; + } + + /* + * Groupings + */ + + grouping performance-metrics-attributes-packet { + description + "Contains Performance Metrics (PM) information."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions + RFC 7823: Performance-Based Path Selection for Explicitly + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; + uses te-types:performance-metrics-attributes { + augment "performance-metrics-one-way" { + description + "Performance Metrics (PM) one-way packet-specific + augmentation for a generic PM grouping."; + leaf one-way-min-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + description + "One-way minimum delay or latency."; + } + leaf one-way-min-delay-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "One-way minimum delay or latency normality."; + } + leaf one-way-max-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + description + "One-way maximum delay or latency."; + } + leaf one-way-max-delay-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "One-way maximum delay or latency normality."; + } + leaf one-way-delay-variation { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + description + "One-way delay variation."; + reference + "RFC 5481: Packet Delay Variation Applicability + Statement, Section 4.2"; + } + leaf one-way-delay-variation-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "One-way delay variation normality."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions + RFC 7823: Performance-Based Path Selection for + Explicitly Routed Label Switched Paths (LSPs) + Using TE Metric Extensions"; + } + leaf one-way-packet-loss { + type decimal64 { + fraction-digits 6; + range "0..50.331642"; + } + units "percent"; + description + "One-way packet loss as a percentage of the total traffic + sent over a configurable interval. + + The finest precision is 0.000003%."; + reference + "RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions, Section 4.4"; + } + leaf one-way-packet-loss-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "Packet loss normality."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions + RFC 7823: Performance-Based Path Selection for + Explicitly Routed Label Switched Paths (LSPs) + Using TE Metric Extensions"; + } + } + augment "performance-metrics-two-way" { + description + "Performance Metrics (PM) two-way packet-specific + augmentation for a generic PM grouping."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions + RFC 7823: Performance-Based Path Selection for Explicitly + Routed Label Switched Paths (LSPs) Using TE + Metric Extensions"; + leaf two-way-min-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way minimum delay or latency."; + } + leaf two-way-min-delay-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "Two-way minimum delay or latency normality."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions + RFC 7823: Performance-Based Path Selection for + Explicitly Routed Label Switched Paths (LSPs) + Using TE Metric Extensions"; + } + leaf two-way-max-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way maximum delay or latency."; + } + leaf two-way-max-delay-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "Two-way maximum delay or latency normality."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions + RFC 7823: Performance-Based Path Selection for + Explicitly Routed Label Switched Paths (LSPs) + Using TE Metric Extensions"; + } + leaf two-way-delay-variation { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way delay variation."; + reference + "RFC 5481: Packet Delay Variation Applicability + Statement, Section 4.2"; + } + leaf two-way-delay-variation-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "Two-way delay variation normality."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions + RFC 7823: Performance-Based Path Selection for + Explicitly Routed Label Switched Paths (LSPs) + Using TE Metric Extensions"; + } + leaf two-way-packet-loss { + type decimal64 { + fraction-digits 6; + range "0..50.331642"; + } + units "percent"; + default "0"; + description + "Two-way packet loss as a percentage of the total traffic + sent over a configurable interval. + + The finest precision is 0.000003%."; + } + leaf two-way-packet-loss-normality { + type te-types:performance-metrics-normality; + default "normal"; + description + "Two-way packet loss normality."; + } + } + } + } + + grouping one-way-performance-metrics-packet { + description + "One-way packet Performance Metrics (PM) throttle grouping."; + leaf one-way-min-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "One-way minimum delay or latency."; + } + leaf one-way-max-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "One-way maximum delay or latency."; + } + leaf one-way-delay-variation { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "One-way delay variation."; + } + leaf one-way-packet-loss { + type decimal64 { + fraction-digits 6; + range "0..50.331642"; + } + units "percent"; + default "0"; + description + "One-way packet loss as a percentage of the total traffic + sent over a configurable interval. + + The finest precision is 0.000003%."; + } + } + + grouping one-way-performance-metrics-gauge-packet { + description + "One-way packet Performance Metrics (PM) throttle grouping. + + This grouping is used to report the same metrics defined in + the one-way-performance-metrics-packet grouping, using gauges + instead of uint32 data types and referencing IPPM RFCs + instead of IGP-TE RFCs."; + leaf one-way-min-delay { + type yang:gauge64; + units "microseconds"; + description + "One-way minimum delay or latency."; + } + leaf one-way-max-delay { + type yang:gauge64; + units "microseconds"; + description + "One-way maximum delay or latency."; + reference + "RFC 7679: A One-Way Delay Metric for IP Performance + Metrics (IPPM)"; + } + leaf one-way-delay-variation { + type yang:gauge64; + units "microseconds"; + description + "One-way delay variation."; + reference + "RFC 3393: IP Packet Delay Variation Metric for IP + Performance Metrics (IPPM)"; + } + leaf one-way-packet-loss { + type decimal64 { + fraction-digits 5; + range "0..100"; + } + description + "The ratio of packets dropped to packets transmitted between + two endpoints."; + reference + "RFC 7680: A One-Way Loss Metric for IP Performance + Metrics (IPPM)"; + } + } + + grouping two-way-performance-metrics-packet { + description + "Two-way packet Performance Metrics (PM) throttle grouping."; + leaf two-way-min-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way minimum delay or latency."; + } + leaf two-way-max-delay { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way maximum delay or latency."; + } + leaf two-way-delay-variation { + type uint32 { + range "0..16777215"; + } + units "microseconds"; + default "0"; + description + "Two-way delay variation."; + } + leaf two-way-packet-loss { + type decimal64 { + fraction-digits 6; + range "0..50.331642"; + } + units "percent"; + default "0"; + description + "Two-way packet loss as a percentage of the total traffic + sent over a configurable interval. + + The finest precision is 0.000003%."; + } + } + + grouping two-way-performance-metrics-gauge-packet { + description + "Two-way packet Performance Metrics (PM) throttle grouping. + + This grouping is used to report the same metrics defined in + the two-way-performance-metrics-packet grouping, using gauges + instead of uint32 data types and referencing IPPM RFCs + instead of IGP-TE RFCs."; + leaf two-way-min-delay { + type yang:gauge64; + units "microseconds"; + description + "Two-way minimum delay or latency."; + reference + "RFC 2681: A Round-trip Delay Metric for IPPM"; + } + leaf two-way-max-delay { + type yang:gauge64; + units "microseconds"; + description + "Two-way maximum delay or latency."; + reference + "RFC 2681: A Round-trip Delay Metric for IPPM"; + } + leaf two-way-delay-variation { + type yang:gauge64; + units "microseconds"; + description + "Two-way delay variation."; + reference + "RFC 5481: Packet Delay Variation Applicability Statement"; + } + leaf two-way-packet-loss { + type decimal64 { + fraction-digits 5; + range "0..100"; + } + description + "The ratio of packets dropped to packets transmitted between + two endpoints."; + } + } + + grouping performance-metrics-throttle-container-packet { + description + "Packet Performance Metrics (PM) threshold grouping."; + uses te-types:performance-metrics-throttle-container { + augment "throttle/threshold-out" { + description + "Performance Metrics (PM) threshold-out packet + augmentation for a generic grouping."; + uses one-way-performance-metrics-packet; + uses two-way-performance-metrics-packet; + } + augment "throttle/threshold-in" { + description + "Performance Metrics (PM) threshold-in packet augmentation + for a generic grouping."; + uses one-way-performance-metrics-packet; + uses two-way-performance-metrics-packet; + } + augment "throttle/threshold-accelerated-advertisement" { + description + "Performance Metrics (PM) accelerated advertisement packet + augmentation for a generic grouping."; + uses one-way-performance-metrics-packet; + uses two-way-performance-metrics-packet; + } + } + } + + grouping bandwidth-profile-parameters { + description + "Common parameters to define bandwidth profiles, also known as + traffic profiles in RFC 2475, that may be used to specify the + temporal properties of a packet stream (e.g., MPLS-TE LSPs), + e.g., as specified in MEF 10, RFC 2697 or RFC 2698."; + reference + "RFC 2475: An Architecture for Differentiated Services + MEF 10.3: Ethernet Services Attributes Phase 3 + RFC 2697: A Single Rate Three Color Marker + RFC 2698: A Two Rate Three Color Marker"; + leaf cir { + type uint64; + units "bits per second"; + description + "Committed Information Rate (CIR)."; + } + leaf cbs { + type uint64; + units "bytes"; + description + "Committed Burst Size (CBS)."; + } + leaf eir { + type uint64; + units "bits per second"; + description + "Excess Information Rate (EIR)."; + } + leaf ebs { + type uint64; + units "bytes"; + description + "Excess Burst Size (EBS)."; + } + leaf pir { + type uint64; + units "bits per second"; + description + "Peak Information Rate (PIR)."; + } + leaf pbs { + type uint64; + units "bytes"; + description + "Peak Burst Size (PBS)."; + } + } + + grouping te-packet-path-bandwidth { + description + "Bandwidth attributes for TE Packet paths."; + container packet-bandwidth { + description + "Bandwidth attributes for TE Packet paths."; + leaf specification-type { + type te-bandwidth-requested-type; + description + "The bandwidth specification type, either explicitly + specified or automatically computed."; + } + leaf set-bandwidth { + when "../specification-type = 'specified-value'" { + description + "When the bandwidth value is explicitly specified."; + } + type bandwidth-kbps; + description + "Set the bandwidth value explicitly, e.g., using offline + calculation."; + } + container bandwidth-profile { + when "../specification-type = 'specified-profile'" { + description + "When the bandwidth profile is explicitly specified."; + } + description + "Set the bandwidth profile attributes explicitly."; + leaf bandwidth-profile-name { + type string; + description + "Name of Bandwidth Profile."; + } + leaf bandwidth-profile-type { + type identityref { + base bandwidth-profile-type; + } + description + "Type of Bandwidth Profile."; + } + uses bandwidth-profile-parameters; + } + leaf class-type { + type te-types:te-ds-class; + description + "The Class-Type of traffic transported by the LSP."; + reference + "RFC 4124: Protocol Extensions for Support of + Diffserv-aware MPLS Traffic Engineering, + Section 4.3.1"; + } + leaf signaled-bandwidth { + type te-packet-types:bandwidth-kbps; + config false; + description + "The currently signaled bandwidth of the LSP. + + In the case where the bandwidth is specified + explicitly, then this will match the value of the + set-bandwidth leaf. + + In the cases where the bandwidth is dynamically + computed by the system, the current value of the + bandwidth should be reflected."; + } + } + } + + grouping te-packet-link-bandwidth { + description + "Bandwidth attributes for Packet TE links."; + leaf packet-bandwidth { + type uint64; + units "bits per second"; + description + "Bandwidth value for Packet TE links."; + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-te-topology-packet@2024-06-08.yang b/src/nbi/service/ietf_network/yang/ietf-te-topology-packet@2024-06-08.yang new file mode 100644 index 0000000000000000000000000000000000000000..3a9b181135c73b910c4a33effb9131a136fd28c1 --- /dev/null +++ b/src/nbi/service/ietf_network/yang/ietf-te-topology-packet@2024-06-08.yang @@ -0,0 +1,91 @@ +module ietf-te-topology-packet { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-te-topology-packet"; + prefix "tet-pkt"; + + import ietf-network { + prefix "nw"; + reference "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-network-topology { + prefix "nt"; + reference "RFC 8345: A YANG Data Model for Network Topologies"; + } + + import ietf-routing-types { + prefix "rt-types"; + reference "RFC 8294: Common YANG Data Types for the Routing Area"; + } + + import ietf-te-topology { + prefix "tet"; + reference "RFC 8795: YANG Data Model for Traffic Engineering (TE) Topologies"; + } + + import ietf-te-types { + prefix "te-types"; + reference "I-D.ietf-teas-rfc8776-update: Common YANG Data Types for Traffic Engineering"; + } + + import ietf-te-packet-types { + prefix "te-packet-types"; + reference + "I-D.ietf-teas-rfc8776-update: Common YANG Data Types for Traffic Engineering"; + } + + organization "Traffic Engineering Architecture and Signaling (TEAS) Working Group"; + contact "WG Web: WG List: Editor: Xufeng Liu Editor: Igor Bryskin Editor: Vishnu Pavan Beeram Editor: Tarek Saad Editor: Himanshu Shah Editor: Oscar Gonzalez De Dios "; + description "YANG data model for representing and manipulating PSC (Packet Switching) TE Topologies. Copyright (c) 2024 IETF Trust and the persons identified as authors of the code. All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to the license terms contained in, the Revised BSD License set forth in Section 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info). This version of this YANG module is part of RFC XXXX (https://www.rfc-editor.org/info/rfcXXXX); see the RFC itself for full legal notices."; + revision 2024-06-08 { + description "Initial revision"; + reference "RFC XXXX: YANG Data Model for Layer 3 TE Topologies"; + } + + feature te-performance-metric { + description "This feature indicates that the system supports TE performance metric."; + reference "RFC7471: OSPF Traffic Engineering (TE) Metric Extensions. RFC8570: IS-IS Traffic Engineering (TE) Metric Extensions. RFC7823: Performance-Based Path Selection for Explicitly Routed Label Switched Paths (LSPs) Using TE Metric Extensions"; + } + + grouping packet-switch-capable-container { + description "The container of packet switch capable attributes."; + container packet-switch-capable { + description "Interface has packet-switching capabilities."; + leaf minimum-lsp-bandwidth { + type rt-types:bandwidth-ieee-float32; + description "Minimum LSP Bandwidth. Units in bytes per second"; + } + leaf interface-mtu { + type uint16; + description "Interface MTU."; + } + } + } + + augment "/nw:networks/nw:network/nw:network-types/" + "tet:te-topology" { + description "Defines the packet TE topology type."; + container packet { + presence "Indicates packet TE topology."; + description "Its presence identifies the packet TE topology type."; + } + } + + augment "/nw:networks/nw:network/nt:link/tet:te/" + "tet:te-link-attributes" { + when "(../../../nw:network-types/tet:te-topology/tet-pkt:packet)" + " and (tet:interface-switching-capability " + "[tet:switching-capability = 'te-types:switching-psc1'])" { + description "Valid only for PSC"; + } + description "Parameters for PSC TE topology."; + uses te-packet-types:performance-metrics-attributes-packet { + if-feature te-performance-metric; + refine performance-metrics-one-way { + config false; + } + refine performance-metrics-two-way { + config false; + } + } + uses te-packet-types:performance-metrics-throttle-container-packet { + if-feature te-performance-metric; + } + } +} diff --git a/src/nbi/service/ietf_network/yang/ietf-te-types@2020-06-10.yang b/src/nbi/service/ietf_network/yang/ietf-te-types@2026-01-23.yang similarity index 55% rename from src/nbi/service/ietf_network/yang/ietf-te-types@2020-06-10.yang rename to src/nbi/service/ietf_network/yang/ietf-te-types@2026-01-23.yang index 6fc0544dede2128f3e91f8cf5a39caa8cc49ab6e..beb46403456adab0b6486daa32d1faf93648c924 100644 --- a/src/nbi/service/ietf_network/yang/ietf-te-types@2020-06-10.yang +++ b/src/nbi/service/ietf_network/yang/ietf-te-types@2026-01-23.yang @@ -6,18 +6,28 @@ module ietf-te-types { import ietf-inet-types { prefix inet; reference - "RFC 6991: Common YANG Data Types"; + "RFC 9911: Common YANG Data Types, Section 4"; } import ietf-yang-types { prefix yang; reference - "RFC 6991: Common YANG Data Types"; + "RFC 9911: Common YANG Data Types, Section 3"; } import ietf-routing-types { prefix rt-types; reference "RFC 8294: Common YANG Data Types for the Routing Area"; } + import ietf-network { + prefix nw; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + import ietf-network-topology { + prefix nt; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } organization "IETF Traffic Engineering Architecture and Signaling (TEAS) @@ -27,7 +37,7 @@ module ietf-te-types { WG List: Editor: Tarek Saad - + Editor: Rakesh Gandhi @@ -42,9 +52,7 @@ module ietf-te-types { "; description "This YANG module contains a collection of generally useful - YANG data type definitions specific to TE. The model fully - conforms to the Network Management Datastore Architecture - (NMDA). + YANG data type definitions specific to TE. The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED', @@ -52,882 +60,553 @@ module ietf-te-types { described in BCP 14 (RFC 2119) (RFC 8174) when, and only when, they appear in all capitals, as shown here. - Copyright (c) 2020 IETF Trust and the persons identified as + Copyright (c) 2026 IETF Trust and the persons identified as authors of the code. All rights reserved. Redistribution and use in source and binary forms, with or without modification, is permitted pursuant to, and subject to - the license terms contained in, the Simplified BSD License set + the license terms contained in, the Revised BSD License set forth in Section 4.c of the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info). - This version of this YANG module is part of RFC 8776; see the - RFC itself for full legal notices."; - + All revisions of IETF and IANA published modules can be found + at the YANG Parameters registry group + (https://www.iana.org/assignments/yang-parameters). + + This version of this YANG module is part of RFC XXXX; see + the RFC itself for full legal notices."; + + revision 2026-01-23 { + description + "This revision adds the following new identities: + - lsp-provisioning-error-reason; + - association-type-diversity; + - tunnel-admin-state-auto; + - lsp-restoration-restore-none; + - restoration-scheme-rerouting; + - path-metric-optimization-type; + - link-path-metric-type; + - link-metric-type and its derived identities; + - path-computation-error-reason and its derived identities; + - protocol-origin-type and its derived identities; + - svec-objective-function-type and its derived identities; + - svec-metric-type and its derived identities. + + This revision adds the following new data types: + - path-type. + + This revision adds the following new groupings: + - explicit-route-hop-with-srlg; + - encoding-and-switching-type; + - te-generic-node-id. + + This revision updates the following identities: + - objective-function-type; + - action-exercise; + - path-metric-type; + - path-metric-te; + - path-metric-igp; + - path-metric-hop; + - path-metric-delay-average; + - path-metric-delay-minimum; + - path-metric-residual-bandwidth; + - path-metric-optimize-includes; + - path-metric-optimize-excludes; + - te-optimization-criterion. + + This revision updates the following data types: + - te-node-id. + + This revision updates the following groupings: + - explicit-route-hop: + - adds the following leaves: + - node-id-uri; + - link-tp-id-uri; + - updates the following leaves: + - node-id; + - link-tp-id; + - record-route-state: + - adds the following leaves: + - node-id-uri; + - link-tp-id-uri; + - updates the following leaves: + - node-id; + - link-tp-id; + - optimization-metric-entry: + - updates the following leaves: + - metric-type; + - tunnel-constraints; + - adds the following leaves: + - network-id; + - path-constraints-route-objects: + - updates the following containers: + - explicit-route-objects-always; + - generic-path-metric-bounds: + - updates the following leaves: + - metric-type; + - generic-path-optimization + - adds the following leaves: + - tiebreaker; + - deprecate the following containers: + - tiebreakers. + + This revision obsoletes the following identities: + - of-minimize-agg-bandwidth-consumption; + - of-minimize-load-most-loaded-link; + - of-minimize-cost-path-set; + - lsp-protection-reroute-extra; + - lsp-protection-reroute. + + This revision provides also few editorial changes."; + reference + "RFC XXXX: Common YANG Data Types for Traffic Engineering"; + } revision 2020-06-10 { description - "Latest revision of TE types."; + "Initial Version of TE types."; reference "RFC 8776: Common YANG Data Types for Traffic Engineering"; } - /** - * Typedefs + /* + * Features */ - typedef admin-group { - type yang:hex-string { - /* 01:02:03:04 */ - length "1..11"; - } + feature p2mp-te { description - "Administrative group / resource class / color representation - in 'hex-string' type. - The most significant byte in the hex-string is the farthest - to the left in the byte sequence. Leading zero bytes in the - configured value may be omitted for brevity."; + "Indicates support for Point-to-Multipoint TE (P2MP-TE)."; reference - "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2 - RFC 5305: IS-IS Extensions for Traffic Engineering - RFC 7308: Extended Administrative Groups in MPLS Traffic - Engineering (MPLS-TE)"; + "RFC 4875: Extensions to Resource Reservation Protocol - + Traffic Engineering (RSVP-TE) for + Point-to-Multipoint TE Label Switched Paths (LSPs)"; } - typedef admin-groups { - type union { - type admin-group; - type extended-admin-group; - } + feature frr-te { description - "Derived types for TE administrative groups."; + "Indicates support for TE Fast Reroute (FRR)."; + reference + "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP Tunnels"; } - typedef extended-admin-group { - type yang:hex-string; + feature extended-admin-groups { description - "Extended administrative group / resource class / color - representation in 'hex-string' type. - The most significant byte in the hex-string is the farthest - to the left in the byte sequence. Leading zero bytes in the - configured value may be omitted for brevity."; + "Indicates support for TE link extended administrative + groups."; reference "RFC 7308: Extended Administrative Groups in MPLS Traffic - Engineering (MPLS-TE)"; + Engineering (MPLS-TE)"; } - typedef path-attribute-flags { - type union { - type identityref { - base session-attributes-flags; - } - type identityref { - base lsp-attributes-flags; - } - } + feature named-path-affinities { description - "Path attributes flags type."; + "Indicates support for named path affinities."; } - typedef performance-metrics-normality { - type enumeration { - enum unknown { - value 0; - description - "Unknown."; - } - enum normal { - value 1; - description - "Normal. Indicates that the anomalous bit is not set."; - } - enum abnormal { - value 2; - description - "Abnormal. Indicates that the anomalous bit is set."; - } - } + feature named-extended-admin-groups { description - "Indicates whether a performance metric is normal (anomalous - bit not set), abnormal (anomalous bit set), or unknown."; - reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions - RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + "Indicates support for named extended administrative groups."; } - typedef srlg { - type uint32; + feature named-srlg-groups { description - "SRLG type."; - reference - "RFC 4203: OSPF Extensions in Support of Generalized - Multi-Protocol Label Switching (GMPLS) - RFC 5307: IS-IS Extensions in Support of Generalized - Multi-Protocol Label Switching (GMPLS)"; + "Indicates support for named Shared Risk Link Group (SRLG)."; } - typedef te-common-status { - type enumeration { - enum up { - description - "Enabled."; - } - enum down { - description - "Disabled."; - } - enum testing { - description - "In some test mode."; - } - enum preparing-maintenance { - description - "The resource is disabled in the control plane to prepare - for a graceful shutdown for maintenance purposes."; - reference - "RFC 5817: Graceful Shutdown in MPLS and Generalized MPLS - Traffic Engineering Networks"; - } - enum maintenance { - description - "The resource is disabled in the data plane for maintenance - purposes."; - } - enum unknown { - description - "Status is unknown."; - } - } + feature named-path-constraints { description - "Defines a type representing the common states of a TE - resource."; + "Indicates support for named path constraints."; } - typedef te-bandwidth { - type string { - pattern '0[xX](0((\.0?)?[pP](\+)?0?|(\.0?))|' - + '1(\.([\da-fA-F]{0,5}[02468aAcCeE]?)?)?' - + '[pP](\+)?(12[0-7]|' - + '1[01]\d|0?\d?\d)?)|0[xX][\da-fA-F]{1,8}|\d+' - + '(,(0[xX](0((\.0?)?[pP](\+)?0?|(\.0?))|' - + '1(\.([\da-fA-F]{0,5}[02468aAcCeE]?)?)?' - + '[pP](\+)?(12[0-7]|' - + '1[01]\d|0?\d?\d)?)|0[xX][\da-fA-F]{1,8}|\d+))*'; - } + feature path-optimization-metric { description - "This is the generic bandwidth type. It is a string containing - a list of numbers separated by commas, where each of these - numbers can be non-negative decimal, hex integer, or - hex float: + "Indicates support for path optimization metrics."; + } - (dec | hex | float)[*(','(dec | hex | float))] + feature path-optimization-objective-function { + description + "Indicates support for path optimization objective functions."; + } - For the packet-switching type, the string encoding follows - the type 'bandwidth-ieee-float32' as defined in RFC 8294 - (e.g., 0x1p10), where the units are in bytes per second. + /* + * Identities + */ - For the Optical Transport Network (OTN) switching type, - a list of integers can be used, such as '0,2,3,1', indicating - two ODU0s and one ODU3. ('ODU' stands for 'Optical Data - Unit'.) For Dense Wavelength Division Multiplexing (DWDM), - a list of pairs of slot numbers and widths can be used, - such as '0,2,3,3', indicating a frequency slot 0 with - slot width 2 and a frequency slot 3 with slot width 3. - Canonically, the string is represented as all lowercase and in - hex, where the prefix '0x' precedes the hex number."; - reference - "RFC 8294: Common YANG Data Types for the Routing Area - ITU-T Recommendation G.709: Interfaces for the - optical transport network"; + identity lsp-provisioning-error-reason { + description + "Base identity for LSP provisioning errors."; } - typedef te-ds-class { - type uint8 { - range "0..7"; - } + identity session-attributes-flags { description - "The Differentiated Services Class-Type of traffic."; + "Base identity for the RSVP-TE session attributes flags."; + } + + identity local-protection-desired { + base session-attributes-flags; + description + "Local protection is desired."; reference - "RFC 4124: Protocol Extensions for Support of Diffserv-aware - MPLS Traffic Engineering, Section 4.3.1"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.7.1"; } - typedef te-global-id { - type uint32; + identity se-style-desired { + base session-attributes-flags; description - "An identifier to uniquely identify an operator, which can be - either a provider or a client. - The definition of this type is taken from RFCs 6370 and 5003. - This attribute type is used solely to provide a globally - unique context for TE topologies."; + "Shared explicit style, to allow the LSP to be established + and share resources with the old LSP."; reference - "RFC 5003: Attachment Individual Identifier (AII) Types for - Aggregation - RFC 6370: MPLS Transport Profile (MPLS-TP) Identifiers"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels"; } - typedef te-hop-type { - type enumeration { - enum loose { - description - "A loose hop in an explicit path."; - } - enum strict { - description - "A strict hop in an explicit path."; - } - } + identity local-recording-desired { + base session-attributes-flags; description - "Enumerated type for specifying loose or strict paths."; + "Label recording is desired."; reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.3.3"; + Section 4.7.1"; } - typedef te-link-access-type { - type enumeration { - enum point-to-point { - description - "The link is point-to-point."; - } - enum multi-access { - description - "The link is multi-access, including broadcast and NBMA."; - } - } + identity bandwidth-protection-desired { + base session-attributes-flags; description - "Defines a type representing the access type of a TE link."; + "Requests FRR bandwidth protection on LSRs, if present."; reference - "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2"; + "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP + Tunnels"; } - typedef te-label-direction { - type enumeration { - enum forward { - description - "Label allocated for the forward LSP direction."; - } - enum reverse { - description - "Label allocated for the reverse LSP direction."; - } - } + identity node-protection-desired { + base session-attributes-flags; description - "Enumerated type for specifying the forward or reverse - label."; + "Requests FRR node protection on LSRs, if present."; + reference + "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP + Tunnels"; } - typedef te-link-direction { - type enumeration { - enum incoming { - description - "The explicit route represents an incoming link on - a node."; - } - enum outgoing { - description - "The explicit route represents an outgoing link on - a node."; - } - } + identity path-reevaluation-request { + base session-attributes-flags; description - "Enumerated type for specifying the direction of a link on - a node."; + "Indicates that a path re-evaluation (of the + current path in use) is requested. + + Note that this does not trigger any LSP reroutes but + instead just signals a request to evaluate whether a + preferable path exists."; + reference + "RFC 4736: Reoptimization of Multiprotocol Label Switching + (MPLS) Traffic Engineering (TE) Loosely Routed + Label Switched Path (LSP)"; } - typedef te-metric { - type uint32; + identity soft-preemption-desired { + base session-attributes-flags; description - "TE metric."; + "Soft preemption of LSP resources is desired."; reference - "RFC 3785: Use of Interior Gateway Protocol (IGP) Metric as a - second MPLS Traffic Engineering (TE) Metric"; + "RFC 5712: MPLS Traffic Engineering Soft Preemption"; } - typedef te-node-id { - type yang:dotted-quad; + identity lsp-attributes-flags { description - "A type representing the identifier for a node in a TE - topology. - The identifier is represented as 4 octets in dotted-quad - notation. - This attribute MAY be mapped to the Router Address TLV - described in Section 2.4.1 of RFC 3630, the TE Router ID - described in Section 3 of RFC 6827, the Traffic Engineering - Router ID TLV described in Section 4.3 of RFC 5305, or the - TE Router ID TLV described in Section 3.2.1 of RFC 6119. - The reachability of such a TE node MAY be achieved by a - mechanism such as that described in Section 6.2 of RFC 6827."; - reference - "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2, Section 2.4.1 - RFC 5305: IS-IS Extensions for Traffic Engineering, - Section 4.3 - RFC 6119: IPv6 Traffic Engineering in IS-IS, Section 3.2.1 - RFC 6827: Automatically Switched Optical Network (ASON) - Routing for OSPFv2 Protocols, Section 3"; + "Base identity for LSP attributes flags."; } - typedef te-oper-status { - type te-common-status; + identity end-to-end-rerouting-desired { + base lsp-attributes-flags; description - "Defines a type representing the operational status of - a TE resource."; + "Indicates end-to-end rerouting behavior for an LSP + undergoing establishment. + + This MAY also be used to specify the behavior of end-to-end + LSP recovery for established LSPs."; + reference + "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS + RSVP-TE + RFC 5420: Encoding of Attributes for MPLS LSP Establishment + Using Resource Reservation Protocol Traffic + Engineering (RSVP-TE) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-admin-status { - type te-common-status; + identity boundary-rerouting-desired { + base lsp-attributes-flags; description - "Defines a type representing the administrative status of - a TE resource."; + "Indicates boundary rerouting behavior for an LSP undergoing + establishment. + + This MAY also be used to specify segment-based LSP recovery + through nested crankback for established LSPs. + + The boundary Area Border Router (ABR) / Autonomous System + Border Router (ASBR) can decide to forward the PathErr + message upstream to either an upstream boundary ABR/ASBR or + the ingress LSR. + + Alternatively, it can try to select another egress boundary + LSR."; + reference + "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS + RSVP-TE + RFC 5420: Encoding of Attributes for MPLS LSP Establishment + Using Resource Reservation Protocol Traffic + Engineering (RSVP-TE) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-path-disjointness { - type bits { - bit node { - position 0; - description - "Node disjoint."; - } - bit link { - position 1; - description - "Link disjoint."; - } - bit srlg { - position 2; - description - "SRLG (Shared Risk Link Group) disjoint."; - } - } + identity segment-based-rerouting-desired { + base lsp-attributes-flags; description - "Type of the resource disjointness for a TE tunnel path."; + "Indicates segment-based rerouting behavior for an LSP + undergoing establishment. + + This MAY also be used to specify segment-based LSP recovery + for established LSPs."; reference - "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS + RSVP-TE + RFC 5420: Encoding of Attributes for MPLS LSP Establishment + Using Resource Reservation Protocol + Traffic Engineering (RSVP-TE) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-recovery-status { - type enumeration { - enum normal { - description - "Both the recovery span and the working span are fully - allocated and active, data traffic is being - transported over (or selected from) the working - span, and no trigger events are reported."; - } - enum recovery-started { - description - "The recovery action has been started but not completed."; - } - enum recovery-succeeded { - description - "The recovery action has succeeded. The working span has - reported a failure/degrade condition, and the user traffic - is being transported (or selected) on the recovery span."; - } - enum recovery-failed { - description - "The recovery action has failed."; - } - enum reversion-started { - description - "The reversion has started."; - } - enum reversion-succeeded { - description - "The reversion action has succeeded."; - } - enum reversion-failed { - description - "The reversion has failed."; - } - enum recovery-unavailable { - description - "The recovery is unavailable, as a result of either an - operator's lockout command or a failure condition - detected on the recovery span."; - } - enum recovery-admin { - description - "The operator has issued a command to switch the user - traffic to the recovery span."; - } - enum wait-to-restore { - description - "The recovery domain is recovering from a failure/degrade - condition on the working span that is being controlled by - the Wait-to-Restore (WTR) timer."; - } - } + identity lsp-integrity-required { + base lsp-attributes-flags; description - "Defines the status of a recovery action."; + "Indicates that LSP integrity is required."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS) - RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection"; + "RFC 4875: Extensions to Resource Reservation Protocol - + Traffic Engineering (RSVP-TE) for + Point-to-Multipoint TE Label Switched Paths (LSPs) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-template-name { - type string { - pattern '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*'; - } + identity contiguous-lsp-desired { + base lsp-attributes-flags; description - "A type for the name of a TE node template or TE link - template."; + "Indicates that a contiguous LSP is desired."; + reference + "RFC 5151: Inter-Domain MPLS and GMPLS Traffic Engineering -- + Resource Reservation Protocol-Traffic Engineering + (RSVP-TE) Extensions + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-topology-event-type { - type enumeration { - enum add { - value 0; - description - "A TE node or TE link has been added."; - } - enum remove { - value 1; - description - "A TE node or TE link has been removed."; - } - enum update { - value 2; - description - "A TE node or TE link has been updated."; - } - } + identity lsp-stitching-desired { + base lsp-attributes-flags; description - "TE event type for notifications."; + "Indicates that LSP stitching is desired."; + reference + "RFC 5150: Label Switched Path Stitching with Generalized + Multiprotocol Label Switching Traffic Engineering + (GMPLS TE) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-topology-id { - type union { - type string { - length "0"; - // empty string - } - type string { - pattern '([a-zA-Z0-9\-_.]+:)*' - + '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*'; - } - } + identity pre-planned-lsp-flag { + base lsp-attributes-flags; description - "An identifier for a topology. - It is optional to have one or more prefixes at the beginning, - separated by colons. The prefixes can be 'network-types' as - defined in the 'ietf-network' module in RFC 8345, to help the - user better understand the topology before further inquiry - is made."; + "Indicates that the LSP MUST be provisioned in the + control plane only."; reference - "RFC 8345: A YANG Data Model for Network Topologies"; + "RFC 6001: Generalized MPLS (GMPLS) Protocol Extensions for + Multi-Layer and Multi-Region Networks (MLN/MRN) + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - typedef te-tp-id { - type union { - type uint32; - // Unnumbered - type inet:ip-address; - // IPv4 or IPv6 address - } + identity non-php-behavior-flag { + base lsp-attributes-flags; description - "An identifier for a TE link endpoint on a node. - This attribute is mapped to a local or remote link identifier - as defined in RFCs 3630 and 5305."; + "Indicates that non-PHP (non-Penultimate Hop Popping) + behavior for the LSP is desired."; reference - "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2 - RFC 5305: IS-IS Extensions for Traffic Engineering"; + "RFC 6511: Non-Penultimate Hop Popping Behavior and + Out-of-Band Mapping for RSVP-TE Label Switched + Paths + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - /* TE features */ - - feature p2mp-te { + identity oob-mapping-flag { + base lsp-attributes-flags; description - "Indicates support for Point-to-Multipoint TE (P2MP-TE)."; + "Indicates that signaling of the egress binding information + is out of band (e.g., via the Border Gateway Protocol + (BGP))."; reference - "RFC 4875: Extensions to Resource Reservation Protocol - - Traffic Engineering (RSVP-TE) for Point-to-Multipoint TE - Label Switched Paths (LSPs)"; + "RFC 6511: Non-Penultimate Hop Popping Behavior and + Out-of-Band Mapping for RSVP-TE Label Switched + Paths + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - feature frr-te { + identity entropy-label-capability { + base lsp-attributes-flags; description - "Indicates support for TE Fast Reroute (FRR)."; + "Indicates entropy label capability."; reference - "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP Tunnels"; + "RFC 6790: The Use of Entropy Labels in MPLS Forwarding + RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO)"; } - feature extended-admin-groups { + identity oam-mep-entity-desired { + base lsp-attributes-flags; description - "Indicates support for TE link extended administrative - groups."; + "OAM Maintenance Entity Group End Point (MEP) entities + desired."; reference - "RFC 7308: Extended Administrative Groups in MPLS Traffic - Engineering (MPLS-TE)"; + "RFC 7260: GMPLS RSVP-TE Extensions for Operations, + Administration, and Maintenance (OAM) + Configuration"; } - feature named-path-affinities { + identity oam-mip-entity-desired { + base lsp-attributes-flags; description - "Indicates support for named path affinities."; + "OAM Maintenance Entity Group Intermediate Points (MIP) + entities desired."; + reference + "RFC 7260: GMPLS RSVP-TE Extensions for Operations, + Administration, and Maintenance (OAM) + Configuration"; } - feature named-extended-admin-groups { + identity srlg-collection-desired { + base lsp-attributes-flags; description - "Indicates support for named extended administrative groups."; + "Shared Risk Link Group (SRLG) collection desired."; + reference + "RFC 7570: Label Switched Path (LSP) Attribute in the + Explicit Route Object (ERO) + RFC 8001: RSVP-TE Extensions for Collecting Shared Risk + Link Group (SRLG) Information"; } - feature named-srlg-groups { + identity loopback-desired { + base lsp-attributes-flags; description - "Indicates support for named SRLG groups."; + "Indicates that a particular node on the LSP is + required to enter loopback mode. + + This can also be used to specify the loopback state of the + node."; + reference + "RFC 7571: GMPLS RSVP-TE Extensions for Lock Instruct and + Loopback"; } - feature named-path-constraints { + identity p2mp-te-tree-eval-request { + base lsp-attributes-flags; description - "Indicates support for named path constraints."; + "P2MP-TE tree re-evaluation request."; + reference + "RFC 8149: RSVP Extensions for Reoptimization of Loosely + Routed Point-to-Multipoint Traffic Engineering + Label Switched Paths (LSPs)"; } - feature path-optimization-metric { + identity rtm-set-desired { + base lsp-attributes-flags; description - "Indicates support for path optimization metrics."; + "Residence Time Measurement (RTM) attribute flag requested."; + reference + "RFC 8169: Residence Time Measurement in MPLS Networks"; } - feature path-optimization-objective-function { + identity link-protection-type { description - "Indicates support for path optimization objective functions."; + "Base identity for the link protection type."; + reference + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } - /* - * Identities - */ - - identity session-attributes-flags { + identity link-protection-unprotected { + base link-protection-type; description - "Base identity for the RSVP-TE session attributes flags."; + "'Unprotected' link protection type."; + reference + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } - identity local-protection-desired { - base session-attributes-flags; + identity link-protection-extra-traffic { + base link-protection-type; description - "Local protection is desired."; + "'Extra-Traffic' link protection type."; reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.7.1"; - } - - identity se-style-desired { - base session-attributes-flags; - description - "Shared explicit style, to allow the LSP to be established - and share resources with the old LSP."; - reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels"; - } - - identity local-recording-desired { - base session-attributes-flags; - description - "Label recording is desired."; - reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.7.1"; - } - - identity bandwidth-protection-desired { - base session-attributes-flags; - description - "Requests FRR bandwidth protection on LSRs, if present."; - reference - "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP Tunnels"; - } - - identity node-protection-desired { - base session-attributes-flags; - description - "Requests FRR node protection on LSRs, if present."; - reference - "RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP Tunnels"; - } - - identity path-reevaluation-request { - base session-attributes-flags; - description - "This flag indicates that a path re-evaluation (of the - current path in use) is requested. Note that this does - not trigger any LSP reroutes but instead just signals a - request to evaluate whether a preferable path exists."; - reference - "RFC 4736: Reoptimization of Multiprotocol Label Switching - (MPLS) Traffic Engineering (TE) Loosely Routed Label Switched - Path (LSP)"; - } - - identity soft-preemption-desired { - base session-attributes-flags; - description - "Soft preemption of LSP resources is desired."; - reference - "RFC 5712: MPLS Traffic Engineering Soft Preemption"; - } - - identity lsp-attributes-flags { - description - "Base identity for LSP attributes flags."; - } - - identity end-to-end-rerouting-desired { - base lsp-attributes-flags; - description - "Indicates end-to-end rerouting behavior for an LSP - undergoing establishment. This MAY also be used to - specify the behavior of end-to-end LSP recovery for - established LSPs."; - reference - "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS - RSVP-TE - RFC 5420: Encoding of Attributes for MPLS LSP Establishment - Using Resource Reservation Protocol Traffic Engineering - (RSVP-TE) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity boundary-rerouting-desired { - base lsp-attributes-flags; - description - "Indicates boundary rerouting behavior for an LSP undergoing - establishment. This MAY also be used to specify - segment-based LSP recovery through nested crankback for - established LSPs. The boundary Area Border Router (ABR) / - Autonomous System Border Router (ASBR) can decide to forward - the PathErr message upstream to either an upstream boundary - ABR/ASBR or the ingress LSR. Alternatively, it can try to - select another egress boundary LSR."; - reference - "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS - RSVP-TE - RFC 5420: Encoding of Attributes for MPLS LSP Establishment - Using Resource Reservation Protocol Traffic Engineering - (RSVP-TE) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity segment-based-rerouting-desired { - base lsp-attributes-flags; - description - "Indicates segment-based rerouting behavior for an LSP - undergoing establishment. This MAY also be used to specify - segment-based LSP recovery for established LSPs."; - reference - "RFC 4920: Crankback Signaling Extensions for MPLS and GMPLS - RSVP-TE - RFC 5420: Encoding of Attributes for MPLS LSP Establishment - Using Resource Reservation Protocol Traffic Engineering - (RSVP-TE) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity lsp-integrity-required { - base lsp-attributes-flags; - description - "Indicates that LSP integrity is required."; - reference - "RFC 4875: Extensions to Resource Reservation Protocol - - Traffic Engineering (RSVP-TE) for Point-to-Multipoint TE - Label Switched Paths (LSPs) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity contiguous-lsp-desired { - base lsp-attributes-flags; - description - "Indicates that a contiguous LSP is desired."; - reference - "RFC 5151: Inter-Domain MPLS and GMPLS Traffic Engineering -- - Resource Reservation Protocol-Traffic Engineering (RSVP-TE) - Extensions - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity lsp-stitching-desired { - base lsp-attributes-flags; - description - "Indicates that LSP stitching is desired."; - reference - "RFC 5150: Label Switched Path Stitching with Generalized - Multiprotocol Label Switching Traffic Engineering (GMPLS TE) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity pre-planned-lsp-flag { - base lsp-attributes-flags; - description - "Indicates that the LSP MUST be provisioned in the - control plane only."; - reference - "RFC 6001: Generalized MPLS (GMPLS) Protocol Extensions for - Multi-Layer and Multi-Region Networks (MLN/MRN) - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity non-php-behavior-flag { - base lsp-attributes-flags; - description - "Indicates that non-PHP (non-Penultimate Hop Popping) behavior - for the LSP is desired."; - reference - "RFC 6511: Non-Penultimate Hop Popping Behavior and Out-of-Band - Mapping for RSVP-TE Label Switched Paths - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity oob-mapping-flag { - base lsp-attributes-flags; - description - "Indicates that signaling of the egress binding information is - out of band (e.g., via the Border Gateway Protocol (BGP))."; - reference - "RFC 6511: Non-Penultimate Hop Popping Behavior and Out-of-Band - Mapping for RSVP-TE Label Switched Paths - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity entropy-label-capability { - base lsp-attributes-flags; - description - "Indicates entropy label capability."; - reference - "RFC 6790: The Use of Entropy Labels in MPLS Forwarding - RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO)"; - } - - identity oam-mep-entity-desired { - base lsp-attributes-flags; - description - "OAM Maintenance Entity Group End Point (MEP) entities - desired."; - reference - "RFC 7260: GMPLS RSVP-TE Extensions for Operations, - Administration, and Maintenance (OAM) Configuration"; - } - - identity oam-mip-entity-desired { - base lsp-attributes-flags; - description - "OAM Maintenance Entity Group Intermediate Points (MIP) - entities desired."; - reference - "RFC 7260: GMPLS RSVP-TE Extensions for Operations, - Administration, and Maintenance (OAM) Configuration"; - } - - identity srlg-collection-desired { - base lsp-attributes-flags; - description - "SRLG collection desired."; - reference - "RFC 7570: Label Switched Path (LSP) Attribute in the Explicit - Route Object (ERO) - RFC 8001: RSVP-TE Extensions for Collecting Shared Risk - Link Group (SRLG) Information"; - } - - identity loopback-desired { - base lsp-attributes-flags; - description - "This flag indicates that a particular node on the LSP is - required to enter loopback mode. This can also be - used to specify the loopback state of the node."; - reference - "RFC 7571: GMPLS RSVP-TE Extensions for Lock Instruct and - Loopback"; - } - - identity p2mp-te-tree-eval-request { - base lsp-attributes-flags; - description - "P2MP-TE tree re-evaluation request."; - reference - "RFC 8149: RSVP Extensions for Reoptimization of Loosely Routed - Point-to-Multipoint Traffic Engineering Label Switched Paths - (LSPs)"; - } - - identity rtm-set-desired { - base lsp-attributes-flags; - description - "Residence Time Measurement (RTM) attribute flag requested."; - reference - "RFC 8169: Residence Time Measurement in MPLS Networks"; - } - - identity link-protection-type { - description - "Base identity for the link protection type."; - } - - identity link-protection-unprotected { - base link-protection-type; - description - "Unprotected link type."; - reference - "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; - } - - identity link-protection-extra-traffic { - base link-protection-type; - description - "Extra-Traffic protected link type."; - reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } identity link-protection-shared { base link-protection-type; description - "Shared protected link type."; + "'Shared' link protection type."; reference - "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } identity link-protection-1-for-1 { base link-protection-type; description - "One-for-one (1:1) protected link type."; + "'Dedicated 1:1' link protection type."; reference - "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } identity link-protection-1-plus-1 { base link-protection-type; description - "One-plus-one (1+1) protected link type."; + "'Dedicated 1+1' link protection type."; reference - "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } identity link-protection-enhanced { base link-protection-type; description - "A compound link protection type derived from the underlay - TE tunnel protection configuration supporting the TE link."; + "'Enhanced' link protection type."; + reference + "RFC 4202: Routing Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS), + section 2.2 + RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) + Signaling Functional Description, section 7"; } identity association-type { @@ -942,7 +621,8 @@ module ietf-te-types { same tunnel for recovery."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery RFC 6780: RSVP ASSOCIATION Object Extensions"; } @@ -964,7 +644,7 @@ module ietf-te-types { independently configured on either endpoint."; reference "RFC 7551: RSVP-TE Extensions for Associated Bidirectional - Label Switched Paths (LSPs)"; + Label Switched Paths (LSPs)"; } identity association-type-single-sided-bidir { @@ -977,12 +657,23 @@ module ietf-te-types { reference "RFC 6780: RSVP ASSOCIATION Object Extensions RFC 7551: RSVP-TE Extensions for Associated Bidirectional - Label Switched Paths (LSPs)"; + Label Switched Paths (LSPs)"; + } + + identity association-type-diversity { + base association-type; + description + "Association Type diversity used to associate LSPs whose + paths are to be diverse from each other."; + reference + "RFC 8800: Path Computation Element Communication Protocol + (PCEP) Extension for Label Switched Path (LSP) + Diversity Constraint Signaling"; } identity objective-function-type { description - "Base objective function type."; + "Base identity for path objective function types."; } identity of-minimize-cost-path { @@ -991,7 +682,8 @@ module ietf-te-types { "Objective function for minimizing path cost."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity of-minimize-load-path { @@ -1001,7 +693,8 @@ module ietf-te-types { paths."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity of-maximize-residual-bandwidth { @@ -1010,36 +703,55 @@ module ietf-te-types { "Objective function for maximizing residual bandwidth."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity of-minimize-agg-bandwidth-consumption { base objective-function-type; + status obsolete; description "Objective function for minimizing aggregate bandwidth - consumption."; + consumption. + + This identity has been obsoleted: the + 'svec-of-minimize-agg-bandwidth-consumption' identity SHOULD + be used instead."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity of-minimize-load-most-loaded-link { base objective-function-type; + status obsolete; description "Objective function for minimizing the load on the link that - is carrying the highest load."; + is carrying the highest load. + + This identity has been obsoleted: the + 'svec-of-minimize-load-most-loaded-link' identity SHOULD + be used instead."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity of-minimize-cost-path-set { base objective-function-type; + status obsolete; description - "Objective function for minimizing the cost on a path set."; + "Objective function for minimizing the cost on a path set. + + This identity has been obsoleted: the + 'svec-of-minimize-cost-path-set' identity SHOULD + be used instead."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity path-computation-method { @@ -1053,8 +765,8 @@ module ietf-te-types { "Indicates a constrained-path LSP in which the path is computed by the local LER."; reference - "RFC 3272: Overview and Principles of Internet Traffic - Engineering, Section 5.4"; + "RFC 9522: Overview and Principles of Internet Traffic + Engineering, Section 4.4"; } identity path-externally-queried { @@ -1064,14 +776,15 @@ module ietf-te-types { querying an external source, such as a PCE server. In the case that an LSP is defined to be externally queried, it may also have associated explicit definitions (provided - to the external source to aid computation). The path that is - returned by the external source may require further local - computation on the device."; + to the external source to aid computation). + + The path that is returned by the external source may + require further local computation on the device."; reference - "RFC 3272: Overview and Principles of Internet Traffic - Engineering + "RFC 9522: Overview and Principles of Internet Traffic + Engineering RFC 4657: Path Computation Element (PCE) Communication - Protocol Generic Requirements"; + Protocol Generic Requirements"; } identity path-explicitly-defined { @@ -1082,8 +795,8 @@ module ietf-te-types { hops."; reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels - RFC 3272: Overview and Principles of Internet Traffic - Engineering"; + RFC 9522: Overview and Principles of Internet Traffic + Engineering"; } identity lsp-metric-type { @@ -1099,7 +812,7 @@ module ietf-te-types { cost to the LSP's tail end."; reference "RFC 4657: Path Computation Element (PCE) Communication - Protocol Generic Requirements"; + Protocol Generic Requirements"; } identity lsp-metric-absolute { @@ -1109,7 +822,7 @@ module ietf-te-types { refers is specified as an absolute value."; reference "RFC 4657: Path Computation Element (PCE) Communication - Protocol Generic Requirements"; + Protocol Generic Requirements"; } identity lsp-metric-inherited { @@ -1120,7 +833,7 @@ module ietf-te-types { from the IGP cost."; reference "RFC 4657: Path Computation Element (PCE) Communication - Protocol Generic Requirements"; + Protocol Generic Requirements"; } identity te-tunnel-type { @@ -1142,8 +855,9 @@ module ietf-te-types { "TE P2MP tunnel type."; reference "RFC 4875: Extensions to Resource Reservation Protocol - - Traffic Engineering (RSVP-TE) for Point-to-Multipoint TE - Label Switched Paths (LSPs)"; + Traffic Engineering (RSVP-TE) for + Point-to-Multipoint TE Label Switched Paths + (LSPs)"; } identity tunnel-action-type { @@ -1214,6 +928,15 @@ module ietf-te-types { "Tunnel's administrative state is down."; } + identity tunnel-admin-state-auto { + base tunnel-admin-state-type; + description + "Tunnel administrative auto state. The administrative status + in state datastore transitions to 'tunnel-admin-up' when the + tunnel used by the client layer, and to 'tunnel-admin-down' + when it is not used by the client layer."; + } + identity tunnel-state-type { description "Base identity for TE tunnel states."; @@ -1302,7 +1025,7 @@ module ietf-te-types { valid, but any packet mapped over the tunnel is dropped."; reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 2.5"; + Section 2.5"; } identity path-invalidation-action-teardown { @@ -1311,7 +1034,7 @@ module ietf-te-types { "TE path invalidation action teardown."; reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 2.5"; + Section 2.5"; } identity lsp-restoration-type { @@ -1319,6 +1042,12 @@ module ietf-te-types { "Base identity from which LSP restoration types are derived."; } + identity lsp-restoration-restore-none { + base lsp-restoration-type; + description + "No LSP affected by a failure is restored."; + } + identity lsp-restoration-restore-any { base lsp-restoration-type; description @@ -1337,31 +1066,55 @@ module ietf-te-types { "Base identity for LSP restoration schemes."; } - identity restoration-scheme-preconfigured { + identity restoration-scheme-rerouting { base restoration-scheme-type; description - "Restoration LSP is preconfigured prior to the failure."; + "Restoration LSP is computed, signalled and configured after + the failure detection. + + This restoration scheme is also known as + 'Full LSP Re-routing', with the alternate route being + computed after the failure occurs."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 11"; + } + + identity restoration-scheme-preconfigured { + base restoration-scheme-type; + description + "Restoration LSP is precomputed, presignalled and + preconfigured prior to the failure."; } identity restoration-scheme-precomputed { base restoration-scheme-type; description - "Restoration LSP is precomputed prior to the failure."; + "Restoration LSP is precomputed, but not presignalled nor + preconfigured, prior to the failure. + + This restoration scheme is also known as + 'Full LSP Re-routing', with the alternate route being + precomputed and stored for use when the failure occurs."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 11"; } identity restoration-scheme-presignaled { base restoration-scheme-type; description - "Restoration LSP is presignaled prior to the failure."; + "Restoration LSP is presignaled, but not preconfigured, + prior to the failure. + + This restoration scheme is also known as + 'Pre-planned LSP Re-routing'."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 8"; } identity lsp-protection-type { @@ -1369,7 +1122,8 @@ module ietf-te-types { "Base identity from which LSP protection types are derived."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery"; } identity lsp-protection-unprotected { @@ -1378,25 +1132,39 @@ module ietf-te-types { "'Unprotected' LSP protection type."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery"; } identity lsp-protection-reroute-extra { base lsp-protection-type; + status obsolete; description - "'(Full) Rerouting' LSP protection type."; + "'(Full) Rerouting' LSP protection type. + + This identity has been obsoleted: the + 'restoration-scheme-rerouting' or + 'restoration-scheme-precomputed' identity SHOULD be used + instead."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 11"; } identity lsp-protection-reroute { base lsp-protection-type; + status obsolete; description - "'Rerouting without Extra-Traffic' LSP protection type."; + "'Rerouting without Extra-Traffic' LSP protection type. + + This identity has been obsoleted: the + 'restoration-scheme-presignaled' identity SHOULD be used + instead."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 8"; } identity lsp-protection-1-for-n { @@ -1405,7 +1173,8 @@ module ietf-te-types { "'1:N Protection with Extra-Traffic' LSP protection type."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 7.3"; } identity lsp-protection-1-for-1 { @@ -1414,7 +1183,8 @@ module ietf-te-types { "LSP protection '1:1 Protection Type'."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 7"; } identity lsp-protection-unidir-1-plus-1 { @@ -1423,7 +1193,8 @@ module ietf-te-types { "'1+1 Unidirectional Protection' LSP protection type."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 5"; } identity lsp-protection-bidir-1-plus-1 { @@ -1432,7 +1203,8 @@ module ietf-te-types { "'1+1 Bidirectional Protection' LSP protection type."; reference "RFC 4872: RSVP-TE Extensions in Support of End-to-End - Generalized Multi-Protocol Label Switching (GMPLS) Recovery"; + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 6"; } identity lsp-protection-extra-traffic { @@ -1440,8 +1212,9 @@ module ietf-te-types { description "Extra-Traffic LSP protection type."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery, section 7"; } identity lsp-protection-state { @@ -1453,6 +1226,11 @@ module ietf-te-types { base lsp-protection-state; description "Normal state."; + reference + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity signal-fail-of-protection { @@ -1462,8 +1240,10 @@ module ietf-te-types { that is of higher priority than the forced switchover command."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity lockout-of-protection { @@ -1471,8 +1251,10 @@ module ietf-te-types { description "A Loss of Protection (LoP) command is active."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity forced-switch { @@ -1480,8 +1262,10 @@ module ietf-te-types { description "A forced switchover command is active."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity signal-fail { @@ -1490,8 +1274,10 @@ module ietf-te-types { "There is a signal fail condition on either the working path or the protection path."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity signal-degrade { @@ -1500,8 +1286,10 @@ module ietf-te-types { "There is a signal degrade condition on either the working path or the protection path."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity manual-switch { @@ -1509,17 +1297,21 @@ module ietf-te-types { description "A manual switchover command is active."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity wait-to-restore { base lsp-protection-state; description - "A WTR timer is running."; + "A Wait-to-Restore (WTR) timer is running."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity do-not-revert { @@ -1528,8 +1320,10 @@ module ietf-te-types { "A Do Not Revert (DNR) condition is active because of non-revertive behavior."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity failure-of-protocol { @@ -1538,8 +1332,13 @@ module ietf-te-types { "LSP protection is not working because of a protocol failure condition."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 7271: MPLS Transport Profile (MPLS-TP) Linear Protection + to Match the Operational Expectations of + Synchronous Digital Hierarchy, Optical Transport + Network, and Ethernet Transport Network Operators + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity protection-external-commands { @@ -1555,8 +1354,13 @@ module ietf-te-types { command that prevents any switchover action from being taken and, as such, freezes the current state."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 7271: MPLS Transport Profile (MPLS-TP) Linear Protection + to Match the Operational Expectations of + Synchronous Digital Hierarchy, Optical Transport + Network, and Ethernet Transport Network Operators + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity clear-freeze { @@ -1564,8 +1368,13 @@ module ietf-te-types { description "An action that clears the active freeze state."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 7271: MPLS Transport Profile (MPLS-TP) Linear Protection + to Match the Operational Expectations of + Synchronous Digital Hierarchy, Optical Transport + Network, and Ethernet Transport Network Operators + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity action-lockout-of-normal { @@ -1575,8 +1384,12 @@ module ietf-te-types { command to ensure that the normal traffic is not allowed to use the protection transport entity."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity clear-lockout-of-normal { @@ -1585,8 +1398,12 @@ module ietf-te-types { "An action that clears the active lockout of the normal state."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity action-lockout-of-protection { @@ -1597,55 +1414,78 @@ module ietf-te-types { temporarily not available to transport a traffic signal (either normal or Extra-Traffic)."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity action-forced-switch { base protection-external-commands; description - "A switchover action initiated by an operator command to switch - the Extra-Traffic signal, the normal traffic signal, or the - null signal to the protection transport entity, unless a - switchover command of equal or higher priority is in effect."; + "A switchover action initiated by an operator command to + switch the Extra-Traffic signal, the normal traffic signal, + or the null signal to the protection transport entity, + unless a switchover command of equal or higher priority is + in effect."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity action-manual-switch { base protection-external-commands; description - "A switchover action initiated by an operator command to switch - the Extra-Traffic signal, the normal traffic signal, or - the null signal to the protection transport entity, unless - a fault condition exists on other transport entities or a - switchover command of equal or higher priority is in effect."; + "A switchover action initiated by an operator command to + switch the Extra-Traffic signal, the normal traffic signal, + or the null signal to the protection transport entity, + unless a fault condition exists on other transport entities + or a switchover command of equal or higher priority is in + effect."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity action-exercise { base protection-external-commands; description - "An action that starts testing whether or not APS communication - is operating correctly. It is of lower priority than any - other state or command."; + "An action that starts testing whether or not Automatic + Protection Switching (APS) communication is operating + correctly. + + It is of lower priority than any other state or command."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 7271: MPLS Transport Profile (MPLS-TP) Linear Protection + to Match the Operational Expectations of + Synchronous Digital Hierarchy, Optical Transport + Network, and Ethernet Transport Network Operators + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity clear { base protection-external-commands; description "An action that clears the active near-end lockout of a - protection, forced switchover, manual switchover, WTR state, - or exercise command."; + protection, forced switchover, manual switchover, + Wait-to-Restore (WTR) state, or exercise command."; reference - "RFC 4427: Recovery (Protection and Restoration) Terminology - for Generalized Multi-Protocol Label Switching (GMPLS)"; + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; } identity switching-capabilities { @@ -1653,7 +1493,7 @@ module ietf-te-types { "Base identity for interface switching capabilities."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity switching-psc1 { @@ -1662,7 +1502,7 @@ module ietf-te-types { "Packet-Switch Capable-1 (PSC-1)."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity switching-evpl { @@ -1670,8 +1510,9 @@ module ietf-te-types { description "Ethernet Virtual Private Line (EVPL)."; reference - "RFC 6004: Generalized MPLS (GMPLS) Support for Metro Ethernet - Forum and G.8011 Ethernet Service Switching"; + "RFC 6004: Generalized MPLS (GMPLS) Support for Metro + Ethernet Forum and G.8011 Ethernet Service + Switching"; } identity switching-l2sc { @@ -1680,7 +1521,7 @@ module ietf-te-types { "Layer-2 Switch Capable (L2SC)."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity switching-tdm { @@ -1689,7 +1530,7 @@ module ietf-te-types { "Time-Division-Multiplex Capable (TDM)."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity switching-otn { @@ -1698,7 +1539,8 @@ module ietf-te-types { "OTN-TDM capable."; reference "RFC 7138: Traffic Engineering Extensions to OSPF for GMPLS - Control of Evolving G.709 Optical Transport Networks"; + Control of Evolving G.709 Optical Transport + Networks"; } identity switching-dcsc { @@ -1707,7 +1549,8 @@ module ietf-te-types { "Data Channel Switching Capable (DCSC)."; reference "RFC 6002: Generalized MPLS (GMPLS) Data Channel - Switching Capable (DCSC) and Channel Set Label Extensions"; + Switching Capable (DCSC) and Channel Set Label + Extensions"; } identity switching-lsc { @@ -1716,7 +1559,7 @@ module ietf-te-types { "Lambda-Switch Capable (LSC)."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity switching-fsc { @@ -1725,7 +1568,7 @@ module ietf-te-types { "Fiber-Switch Capable (FSC)."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-types { @@ -1733,7 +1576,7 @@ module ietf-te-types { "Base identity for encoding types."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-packet { @@ -1742,7 +1585,7 @@ module ietf-te-types { "Packet LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-ethernet { @@ -1751,7 +1594,7 @@ module ietf-te-types { "Ethernet LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-pdh { @@ -1760,7 +1603,7 @@ module ietf-te-types { "ANSI/ETSI PDH LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-sdh { @@ -1769,7 +1612,7 @@ module ietf-te-types { "SDH ITU-T G.707 / SONET ANSI T1.105 LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-digital-wrapper { @@ -1778,7 +1621,7 @@ module ietf-te-types { "Digital Wrapper LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-lambda { @@ -1787,7 +1630,7 @@ module ietf-te-types { "Lambda (photonic) LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-fiber { @@ -1796,7 +1639,7 @@ module ietf-te-types { "Fiber LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-fiber-channel { @@ -1805,7 +1648,7 @@ module ietf-te-types { "FiberChannel LSP encoding."; reference "RFC 3471: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Functional Description"; + Signaling Functional Description"; } identity lsp-encoding-oduk { @@ -1814,8 +1657,8 @@ module ietf-te-types { "G.709 ODUk (Digital Path) LSP encoding."; reference "RFC 4328: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Extensions for G.709 Optical Transport Networks - Control"; + Signaling Extensions for G.709 Optical Transport + Networks Control"; } identity lsp-encoding-optical-channel { @@ -1824,8 +1667,8 @@ module ietf-te-types { "G.709 Optical Channel LSP encoding."; reference "RFC 4328: Generalized Multi-Protocol Label Switching (GMPLS) - Signaling Extensions for G.709 Optical Transport Networks - Control"; + Signaling Extensions for G.709 Optical Transport + Networks Control"; } identity lsp-encoding-line { @@ -1834,7 +1677,8 @@ module ietf-te-types { "Line (e.g., 8B/10B) LSP encoding."; reference "RFC 6004: Generalized MPLS (GMPLS) Support for Metro - Ethernet Forum and G.8011 Ethernet Service Switching"; + Ethernet Forum and G.8011 Ethernet Service + Switching"; } identity path-signaling-type { @@ -1894,6 +1738,14 @@ module ietf-te-types { base route-usage-type; description "'Include route' object."; + reference + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.3.2 + RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP), Section 7.12 + RFC 7896: Update to the Include Route Object (IRO) + Specification in the Path Computation Element + Communication Protocol (PCEP)"; } identity route-exclude-object { @@ -1902,84 +1754,195 @@ module ietf-te-types { "'Exclude route' object."; reference "RFC 4874: Exclude Routes - Extension to Resource ReserVation - Protocol-Traffic Engineering (RSVP-TE)"; + Protocol-Traffic Engineering (RSVP-TE)"; } identity route-exclude-srlg { base route-usage-type; description - "Excludes SRLGs."; + "Excludes Shared Risk Link Groups (SRLGs)."; reference "RFC 4874: Exclude Routes - Extension to Resource ReserVation - Protocol-Traffic Engineering (RSVP-TE)"; + Protocol-Traffic Engineering (RSVP-TE)"; } - identity path-metric-type { + identity path-metric-optimization-type { description - "Base identity for the path metric type."; + "Base identity used to define the path metric optimization + types."; } - identity path-metric-te { - base path-metric-type; + identity link-path-metric-type { description - "TE path metric."; - reference - "RFC 3785: Use of Interior Gateway Protocol (IGP) Metric as a - second MPLS Traffic Engineering (TE) Metric"; - } + "Base identity used to define the link and the path metric + types. - identity path-metric-igp { - base path-metric-type; - description - "IGP path metric."; - reference - "RFC 3785: Use of Interior Gateway Protocol (IGP) Metric as a - second MPLS Traffic Engineering (TE) Metric"; + The unit of the path metric value is interpreted in the + context of the path metric type and the derived identities + SHOULD describe the unit of the path metric types they + define."; } - identity path-metric-hop { - base path-metric-type; + identity link-metric-type { + base link-path-metric-type; description - "Hop path metric."; + "Base identity for the link metric types."; } - identity path-metric-delay-average { - base path-metric-type; + identity link-metric-te { + base link-metric-type; description - "Average unidirectional link delay."; + "Traffic Engineering (TE) Link Metric."; reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions"; + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2, Section 2.5.5 + RFC 5305: IS-IS Extensions for Traffic Engineering, + Section 3.7"; + } + + identity link-metric-igp { + base link-metric-type; + description + "Interior Gateway Protocol (IGP) Link Metric."; + reference + "RFC 3785: Use of Interior Gateway Protocol (IGP) Metric + as a second MPLS Traffic Engineering (TE) + Metric"; + } + + identity link-metric-delay-average { + base link-metric-type; + description + "Unidirectional Link Delay, measured in units of + microseconds."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions, Section 4.1 + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions, Section 4.1"; + } + + identity link-metric-delay-minimum { + base link-metric-type; + description + "Minimum unidirectional Link Delay, measured in units of + microseconds."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions, Section 4.2 + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions, Section 4.2"; + } + + identity link-metric-delay-maximum { + base link-metric-type; + description + "Maximum unidirectional Link Delay, measured in units of + microseconds."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions, Section 4.2 + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions, Section 4.2"; + } + + identity link-metric-residual-bandwidth { + base link-metric-type; + description + "Unidirectional Residual Bandwidth, measured in units of + bytes per second. + + It is defined to be Maximum Bandwidth minus the bandwidth + currently allocated to LSPs."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric + Extensions, Section 4.5 + RFC 8570: IS-IS Traffic Engineering (TE) Metric + Extensions, Section 4.5"; + } + + identity path-metric-type { + base link-path-metric-type; + base path-metric-optimization-type; + description + "Base identity for the path metric types."; + } + + identity path-metric-te { + base path-metric-type; + description + "Traffic Engineering (TE) Path Metric."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP), Section 7.8"; + } + + identity path-metric-igp { + base path-metric-type; + description + "Interior Gateway Protocol (IGP) Path Metric."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP), section 7.8"; + } + + identity path-metric-hop { + base path-metric-type; + description + "Hop Count Path Metric."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP), Section 7.8"; + } + + identity path-metric-delay-average { + base path-metric-type; + description + "The Path Delay Metric, measured in units of + microseconds."; + reference + "RFC 8233: Extensions to the Path Computation Element + Communication Protocol (PCEP) to Compute + Service-Aware Label Switched Paths (LSPs), + Section 3.1.1"; } identity path-metric-delay-minimum { base path-metric-type; description - "Minimum unidirectional link delay."; + "The Path Min Delay Metric, measured in units of + microseconds."; reference - "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions"; + "I-D.ietf-pce-sid-algo: Carrying SR-Algorithm information + in PCE-based Networks, + draft-ietf-pce-sid-algo-29, + Sections 4.5.1 and 4.5.2"; } identity path-metric-residual-bandwidth { base path-metric-type; description - "Unidirectional Residual Bandwidth, which is defined to be - Maximum Bandwidth (RFC 3630) minus the bandwidth currently - allocated to LSPs."; + "The Path Residual Bandwidth, defined as the minimum Link + Residual Bandwidth all the links along the path. + + The Path Residual Bandwidth can be seen as the path + metric associated with the Maximum residual Bandwidth Path + (MBP) objective function."; reference - "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2 - RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions"; + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; } identity path-metric-optimize-includes { - base path-metric-type; + base path-metric-optimization-type; description "A metric that optimizes the number of included resources specified in a set."; } identity path-metric-optimize-excludes { - base path-metric-type; + base path-metric-optimization-type; description "A metric that optimizes to a maximum the number of excluded resources specified in a set."; @@ -1993,13 +1956,15 @@ module ietf-te-types { identity path-tiebreaker-minfill { base path-tiebreaker-type; description - "Min-Fill LSP path placement."; + "Min-Fill LSP path placement: selects the path with the most + available bandwidth (load balance LSPs over more links)."; } identity path-tiebreaker-maxfill { base path-tiebreaker-type; description - "Max-Fill LSP path placement."; + "Max-Fill LSP path placement: selects the path with the least + available bandwidth (packing more LSPs over few links)."; } identity path-tiebreaker-random { @@ -2012,7 +1977,8 @@ module ietf-te-types { description "Base identity for resource class affinities."; reference - "RFC 2702: Requirements for Traffic Engineering Over MPLS"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels + RFC 2702: Requirements for Traffic Engineering Over MPLS"; } identity resource-aff-include-all { @@ -2022,8 +1988,8 @@ module ietf-te-types { tunnel, all of which must be present for a link to be acceptable."; reference - "RFC 2702: Requirements for Traffic Engineering Over MPLS - RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels + RFC 2702: Requirements for Traffic Engineering Over MPLS"; } identity resource-aff-include-any { @@ -2033,8 +1999,8 @@ module ietf-te-types { tunnel, any of which must be present for a link to be acceptable."; reference - "RFC 2702: Requirements for Traffic Engineering Over MPLS - RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels + RFC 2702: Requirements for Traffic Engineering Over MPLS"; } identity resource-aff-exclude-any { @@ -2043,16 +2009,16 @@ module ietf-te-types { "The set of attribute filters associated with a tunnel, any of which renders a link unacceptable."; reference - "RFC 2702: Requirements for Traffic Engineering Over MPLS - RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels"; + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels + RFC 2702: Requirements for Traffic Engineering Over MPLS"; } identity te-optimization-criterion { description "Base identity for the TE optimization criteria."; reference - "RFC 3272: Overview and Principles of Internet Traffic - Engineering"; + "RFC 9522: Overview and Principles of Internet Traffic + Engineering"; } identity not-optimized { @@ -2067,7 +2033,8 @@ module ietf-te-types { "Optimized on cost."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity delay { @@ -2076,54 +2043,1009 @@ module ietf-te-types { "Optimized on delay."; reference "RFC 5541: Encoding of Objective Functions in the Path - Computation Element Communication Protocol (PCEP)"; + Computation Element Communication Protocol + (PCEP)"; } identity path-computation-srlg-type { description - "Base identity for SRLG path computation."; + "Base identity for Shared Risk Link Group (SRLG) path + computation."; } identity srlg-ignore { base path-computation-srlg-type; description - "Ignores SRLGs in the path computation."; + "Ignores Shared Risk Link Groups (SRLGs) in the path + computation."; } identity srlg-strict { base path-computation-srlg-type; description - "Includes a strict SRLG check in the path computation."; - } + "Includes a strict Shared Risk Link Group (SRLG) check in + the path computation."; + } + + identity srlg-preferred { + base path-computation-srlg-type; + description + "Includes a preferred Shared Risk Link Group (SRLG) check in + the path computation."; + } + + identity srlg-weighted { + base path-computation-srlg-type; + description + "Includes a weighted Shared Risk Link Group (SRLG) check in + the path computation."; + } + + identity path-computation-error-reason { + description + "Base identity for path computation error reasons."; + } + + identity path-computation-error-path-not-found { + base path-computation-error-reason; + description + "Path computation has failed because of an unspecified + reason."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP), Section 7.5"; + } + + identity path-computation-error-no-topology { + base path-computation-error-reason; + description + "Path computation has failed because there is no topology + with the provided topology-identifier."; + } + + identity path-computation-error-no-dependent-server { + base path-computation-error-reason; + description + "Path computation has failed because one or more dependent + path computation servers are unavailable. + + The dependent path computation server could be + a Backward-Recursive Path Computation (BRPC) downstream + PCE or a child PCE."; + reference + "RFC 5441: A Backward-Recursive PCE-Based Computation (BRPC) + Procedure to Compute Shortest Constrained + Inter-Domain Traffic Engineering Label Switched + Paths + RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture"; + } + + identity path-computation-error-pce-unavailable { + base path-computation-error-reason; + description + "Path computation has failed because PCE is not available. + + It corresponds to bit 31 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP) + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-no-inclusion-hop { + base path-computation-error-reason; + description + "Path computation has failed because there is no + node or link provided by one or more inclusion hops."; + } + + identity path-computation-error-destination-unknown-in-domain { + base path-computation-error-reason; + description + "Path computation has failed because the destination node is + unknown in indicated destination domain. + + It corresponds to bit 19 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-no-resource { + base path-computation-error-reason; + description + "Path computation has failed because there is no + available resource in one or more domains. + + It corresponds to bit 20 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-child-pce-unresponsive { + base path-computation-error-no-dependent-server; + description + "Path computation has failed because child PCE is not + responsive. + + It corresponds to bit 21 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-destination-domain-unknown { + base path-computation-error-reason; + description + "Path computation has failed because the destination domain + was unknown. + + It corresponds to bit 22 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-p2mp { + base path-computation-error-reason; + description + "Path computation has failed because of P2MP reachability + problem. + + It corresponds to bit 24 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 8306: Extensions to the Path Computation Element + Communication Protocol (PCEP) for + Point-to-Multipoint Traffic Engineering Label + Switched Paths + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-no-gco-migration { + base path-computation-error-reason; + description + "Path computation has failed because of no Global Concurrent + Optimization (GCO) migration path found. + + It corresponds to bit 26 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5557: Path Computation Element Communication Protocol + (PCEP) Requirements and Protocol Extensions in + Support of Global Concurrent Optimization + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-no-gco-solution { + base path-computation-error-reason; + description + "Path computation has failed because of no GCO solution + found. + + It corresponds to bit 25 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5557: Path Computation Element Communication Protocol + (PCEP) Requirements and Protocol Extensions in + Support of Global Concurrent Optimization + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-pks-expansion { + base path-computation-error-reason; + description + "Path computation has failed because of Path-Key Subobject + (PKS) expansion failure. + + It corresponds to bit 27 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5520: Preserving Topology Confidentiality in + Inter-Domain Path Computation Using a + Path-Key-Based Mechanism + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-brpc-chain-unavailable { + base path-computation-error-no-dependent-server; + description + "Path computation has failed because PCE BRPC chain + unavailable. + + It corresponds to bit 28 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5441: A Backward-Recursive PCE-Based Computation (BRPC) + Procedure to Compute Shortest Constrained + Inter-Domain Traffic Engineering Label Switched + Paths + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-source-unknown { + base path-computation-error-reason; + description + "Path computation has failed because source node is + unknown. + + It corresponds to bit 29 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP); + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity path-computation-error-destination-unknown { + base path-computation-error-reason; + description + "Path computation has failed because destination node is + unknown. + + It corresponds to bit 30 of the Flags field of the + NO-PATH-VECTOR TLV."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP); + + https://www.iana.org/assignments/pcep + /pcep.xhtml#no-path-vector-tlv"; + } + + identity protocol-origin-type { + description + "Base identity for protocol origin type."; + } + + identity protocol-origin-api { + base protocol-origin-type; + description + "Protocol origin is via Application Programming Interface + (API)."; + } + + identity protocol-origin-pcep { + base protocol-origin-type; + description + "Protocol origin is Path Computation Engine Protocol + (PCEP)."; + reference + "RFC 5440: Path Computation Element (PCE) Communication + Protocol (PCEP)"; + } + + identity protocol-origin-bgp { + base protocol-origin-type; + description + "Protocol origin is Border Gateway Protocol (BGP)."; + reference + "RFC 9012: The BGP Tunnel Encapsulation Attribute"; + } + + identity svec-objective-function-type { + description + "Base identity for SVEC objective function type."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol (PCEP)"; + } + + identity svec-of-minimize-agg-bandwidth-consumption { + base svec-objective-function-type; + description + "Objective function for minimizing aggregate bandwidth + consumption (MBC)."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-of-minimize-load-most-loaded-link { + base svec-objective-function-type; + description + "Objective function for minimizing the load on the link that + is carrying the highest load (MLL)."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-of-minimize-cost-path-set { + base svec-objective-function-type; + description + "Objective function for minimizing the cost on a path set + (MCC)."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-of-minimize-common-transit-domain { + base svec-objective-function-type; + description + "Objective function for minimizing the number of common + transit domains (MCTD)."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture."; + } + + identity svec-of-minimize-shared-link { + base svec-objective-function-type; + description + "Objective function for minimizing the number of shared + links (MSL)."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture."; + } + + identity svec-of-minimize-shared-srlg { + base svec-objective-function-type; + description + "Objective function for minimizing the number of shared + Shared Risk Link Groups (SRLG) (MSS)."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture."; + } + + identity svec-of-minimize-shared-nodes { + base svec-objective-function-type; + description + "Objective function for minimizing the number of shared + nodes (MSN)."; + reference + "RFC 8685: Path Computation Element Communication Protocol + (PCEP) Extensions for the Hierarchical Path + Computation Element (H-PCE) Architecture."; + } + + identity svec-metric-type { + description + "Base identity for SVEC metric type."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol (PCEP)"; + } + + identity svec-metric-cumulative-te { + base svec-metric-type; + description + "Cumulative TE cost."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-metric-cumulative-igp { + base svec-metric-type; + description + "Cumulative IGP cost."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-metric-cumulative-hop { + base svec-metric-type; + description + "Cumulative Hop path metric."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-metric-aggregate-bandwidth-consumption { + base svec-metric-type; + description + "Aggregate bandwidth consumption."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + identity svec-metric-load-of-the-most-loaded-link { + base svec-metric-type; + description + "Load of the most loaded link."; + reference + "RFC 5541: Encoding of Objective Functions in the Path + Computation Element Communication Protocol + (PCEP)"; + } + + /* + * Typedefs + */ + + typedef admin-group { + type yang:hex-string { + /* 01:02:03:04 */ + length "1..11"; + } + description + "Administrative group / resource class / color representation + in 'hex-string' type. + + The most significant byte in the hex-string is the farthest + to the left in the byte sequence. + + Leading zero bytes in the configured value may be omitted + for brevity."; + reference + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2 + RFC 5305: IS-IS Extensions for Traffic Engineering + RFC 7308: Extended Administrative Groups in MPLS Traffic + Engineering (MPLS-TE)"; + } + + typedef admin-groups { + type union { + type admin-group; + type extended-admin-group; + } + description + "Derived types for TE administrative groups."; + } + + typedef extended-admin-group { + type yang:hex-string; + description + "Extended administrative group / resource class / color + representation in 'hex-string' type. + + The most significant byte in the hex-string is the farthest + to the left in the byte sequence. + + Leading zero bytes in the configured value may be omitted + for brevity."; + reference + "RFC 7308: Extended Administrative Groups in MPLS Traffic + Engineering (MPLS-TE)"; + } + + typedef path-attribute-flags { + type union { + type identityref { + base session-attributes-flags; + } + type identityref { + base lsp-attributes-flags; + } + } + description + "Path attributes flags type."; + } + + typedef performance-metrics-normality { + type enumeration { + enum unknown { + value 0; + description + "Unknown."; + } + enum normal { + value 1; + description + "Normal. + + Indicates that the anomalous bit is not set."; + } + enum abnormal { + value 2; + description + "Abnormal. + + Indicates that the anomalous bit is set."; + } + } + description + "Indicates whether a performance metric is normal (anomalous + bit not set), abnormal (anomalous bit set), or unknown."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 7823: Performance-Based Path Selection for Explicitly + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + } + + typedef srlg { + type uint32; + description + "Shared Risk Link Group (SRLG) type."; + reference + "RFC 4203: OSPF Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS) + RFC 5307: IS-IS Extensions in Support of Generalized + Multi-Protocol Label Switching (GMPLS)"; + } + + typedef te-common-status { + type enumeration { + enum up { + description + "Enabled."; + } + enum down { + description + "Disabled."; + } + enum testing { + description + "In some test mode."; + } + enum preparing-maintenance { + description + "The resource is disabled in the control plane to prepare + for a graceful shutdown for maintenance purposes."; + reference + "RFC 5817: Graceful Shutdown in MPLS and Generalized MPLS + Traffic Engineering Networks"; + } + enum maintenance { + description + "The resource is disabled in the data plane for maintenance + purposes."; + } + enum unknown { + description + "Status is unknown."; + } + } + description + "Defines a type representing the common states of a TE + resource."; + } + + typedef te-bandwidth { + type string { + pattern '0[xX](0((\.0?)?[pP](\+)?0?|(\.0?))|' + + '1(\.([\da-fA-F]{0,5}[02468aAcCeE]?)?)?' + + '[pP](\+)?(12[0-7]|' + + '1[01]\d|0?\d?\d)?)|0[xX][\da-fA-F]{1,8}|\d+' + + '(,(0[xX](0((\.0?)?[pP](\+)?0?|(\.0?))|' + + '1(\.([\da-fA-F]{0,5}[02468aAcCeE]?)?)?' + + '[pP](\+)?(12[0-7]|' + + '1[01]\d|0?\d?\d)?)|0[xX][\da-fA-F]{1,8}|\d+))*'; + } + description + "This is the generic bandwidth type. + + It is a string containing a list of numbers separated by + commas, where each of these numbers can be non-negative + decimal, hex integer, or hex float, as defined in + ISO/IEC 9899: + + (dec | hex | float)[*(','(dec | hex | float))] + + For the packet-switching type, the string encoding MUST follow + the type 'bandwidth-ieee-float32' as defined in RFC 8294 + (e.g., 0x1p10), where the units are in bytes per second. + + Canonically, the string is represented as all lowercase and in + hex, where the prefix '0x' precedes the hex number."; + reference + "ISO/IEC 9899:2024: Information Technology - Programming + Languages - C, Section 6.4.4.2 + RFC 8294: Common YANG Data Types for the Routing Area"; + } + + typedef te-ds-class { + type uint8 { + range "0..7"; + } + description + "The Differentiated Services Class-Type of traffic."; + reference + "RFC 4124: Protocol Extensions for Support of Diffserv-aware + MPLS Traffic Engineering, Section 4.3.1"; + } + + typedef te-global-id { + type uint32; + description + "An identifier to uniquely identify an operator, which can be + either a provider or a client. + + The definition of this type is taken from RFCs 6370 and 5003. + + This attribute type is used solely to provide a globally + unique context for TE topologies."; + reference + "RFC 5003: Attachment Individual Identifier (AII) Types for + Aggregation + RFC 6370: MPLS Transport Profile (MPLS-TP) Identifiers"; + } + + typedef te-hop-type { + type enumeration { + enum loose { + description + "A loose hop in an explicit path."; + } + enum strict { + description + "A strict hop in an explicit path."; + } + } + description + "Enumerated type for specifying loose or strict paths."; + reference + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.3.3"; + } + + typedef te-link-access-type { + type enumeration { + enum point-to-point { + description + "The link is point-to-point."; + } + enum multi-access { + description + "The link is multi-access, including broadcast and NBMA."; + } + } + description + "The access types of a TE link."; + reference + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2"; + } + + typedef te-label-direction { + type enumeration { + enum forward { + description + "Label allocated for the forward LSP direction."; + } + enum reverse { + description + "Label allocated for the reverse LSP direction."; + } + } + description + "Enumerated type for specifying the forward or reverse + label."; + } + + typedef te-link-direction { + type enumeration { + enum incoming { + description + "The explicit route represents an incoming link on + a node."; + } + enum outgoing { + description + "The explicit route represents an outgoing link on + a node."; + } + } + description + "Enumerated type for specifying the direction of a link on + a node."; + } + + typedef te-metric { + type uint32; + description + "Traffic Engineering (TE) metric."; + reference + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2, Section 2.5.5 + RFC 5305: IS-IS Extensions for Traffic Engineering, + Section 3.7"; + } + + typedef te-node-id { + type union { + type yang:dotted-quad; + type inet:ipv6-address-no-zone; + } + description + "A type representing the identifier for a node in a TE + topology. + + The identifier is represented either as 4 octets in + dotted-quad notation, or as 16 octets in full, mixed, + shortened, or shortened-mixed IPv6 address notation. + + This attribute MAY be mapped to the Router Address TLV + described in Section 2.4.1 of RFC 3630, the TE Router ID + described in Section 3 of RFC 6827, the Traffic Engineering + Router ID TLV described in Section 4.3 of RFC 5305, the TE + Router ID TLV described in Section 3.2.1 of RFC 6119, or the + IPv6 TE Router ID TLV described in Section 4.1 of RFC 6119. + + The reachability of such a TE node MAY be achieved by a + mechanism such as that described in Section 6.2 of RFC 6827."; + reference + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2, Section 2.4.1 + RFC 5305: IS-IS Extensions for Traffic Engineering, + Section 4.3 + RFC 6119: IPv6 Traffic Engineering in IS-IS, Section 3.2.1 + RFC 6827: Automatically Switched Optical Network (ASON) + Routing for OSPFv2 Protocols, Section 3"; + } + + typedef te-oper-status { + type te-common-status; + description + "Defines a type representing the operational status of + a TE resource."; + } + + typedef te-admin-status { + type te-common-status; + description + "Defines a type representing the administrative status of + a TE resource."; + } + + typedef te-path-disjointness { + type bits { + bit node { + position 0; + description + "Node disjoint."; + } + bit link { + position 1; + description + "Link disjoint."; + } + bit srlg { + position 2; + description + "Shared Risk Link Group (SRLG) disjoint."; + } + } + description + "Type of the resource disjointness for a TE tunnel path."; + reference + "RFC 4872: RSVP-TE Extensions in Support of End-to-End + Generalized Multi-Protocol Label Switching (GMPLS) + Recovery"; + } + + typedef te-recovery-status { + type enumeration { + enum normal { + description + "Both the recovery span and the working span are fully + allocated and active, data traffic is being + transported over (or selected from) the working + span, and no trigger events are reported."; + } + enum recovery-started { + description + "The recovery action has been started but not completed."; + } + enum recovery-succeeded { + description + "The recovery action has succeeded. + + The working span has reported a failure/degrade condition, + and the user traffic is being transported (or selected) + on the recovery span."; + } + enum recovery-failed { + description + "The recovery action has failed."; + } + enum reversion-started { + description + "The reversion has started."; + } + enum reversion-succeeded { + description + "The reversion action has succeeded."; + } + enum reversion-failed { + description + "The reversion has failed."; + } + enum recovery-unavailable { + description + "The recovery is unavailable, as a result of either an + operator's lockout command or a failure condition + detected on the recovery span."; + } + enum recovery-admin { + description + "The operator has issued a command to switch the user + traffic to the recovery span."; + } + enum wait-to-restore { + description + "The recovery domain is recovering from a failure/degrade + condition on the working span that is being controlled by + the Wait-to-Restore (WTR) timer."; + } + } + description + "Defines the status of a recovery action."; + reference + "RFC 6378: MPLS Transport Profile (MPLS-TP) Linear Protection + RFC 4427: Recovery (Protection and Restoration) Terminology + for Generalized Multi-Protocol Label Switching + (GMPLS)"; + } + + typedef te-template-name { + type string { + pattern '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*'; + } + description + "A type for the name of a TE node template or TE link + template."; + } + + typedef te-topology-event-type { + type enumeration { + enum add { + value 0; + description + "A TE node or TE link has been added."; + } + enum remove { + value 1; + description + "A TE node or TE link has been removed."; + } + enum update { + value 2; + description + "A TE node or TE link has been updated."; + } + } + description + "TE event type for notifications."; + } + + typedef te-topology-id { + type union { + type string { + length "0"; + // empty string + } + type string { + pattern '([a-zA-Z0-9\-_.]+:)*' + + '/?([a-zA-Z0-9\-_.]+)(/[a-zA-Z0-9\-_.]+)*'; + } + } + description + "An identifier for a topology. + + It is optional to have one or more prefixes at the beginning, + separated by colons. + + The prefixes can be 'network-types' as defined in the + 'ietf-network' module in RFC 8345, to help the user better + understand the topology before further inquiry is made."; + reference + "RFC 8345: A YANG Data Model for Network Topologies"; + } + + typedef te-tp-id { + type union { + type uint32; + // Unnumbered + type inet:ip-address; + // IPv4 or IPv6 address + } + description + "An identifier for a TE link endpoint on a node. - identity srlg-preferred { - base path-computation-srlg-type; - description - "Includes a preferred SRLG check in the path computation."; + This attribute is mapped to a local or remote link identifier + as defined in RFCs 3630 and 5305."; + reference + "RFC 3630: Traffic Engineering (TE) Extensions to OSPF + Version 2 + RFC 5305: IS-IS Extensions for Traffic Engineering"; } - identity srlg-weighted { - base path-computation-srlg-type; + typedef path-type { + type enumeration { + enum primary-path { + description + "Indicates that the TE path is a primary path."; + } + enum secondary-path { + description + "Indicates that the TE path is a secondary path."; + } + enum primary-reverse-path { + description + "Indicates that the TE path is a primary reverse path."; + } + enum secondary-reverse-path { + description + "Indicates that the TE path is a secondary reverse path."; + } + } description - "Includes a weighted SRLG check in the path computation."; + "The type of TE path, indicating whether a path is a primary, + or a reverse primary, or a secondary, or a reverse secondary + path."; } - /** + /* * TE bandwidth groupings - **/ + */ grouping te-bandwidth { description "This grouping defines the generic TE bandwidth. + For some known data-plane technologies, specific modeling - structures are specified. The string-encoded 'te-bandwidth' - type is used for unspecified technologies. + structures are specified. + + The string-encoded 'te-bandwidth' type is used for + unspecified technologies. + The modeling structure can be augmented later for other technologies."; container te-bandwidth { description - "Container that specifies TE bandwidth. The choices - can be augmented for specific data-plane technologies."; + "Container that specifies TE bandwidth. + + The choices can be augmented for specific data-plane + technologies."; choice technology { default "generic"; description @@ -2139,20 +3061,24 @@ module ietf-te-types { } } - /** + /* * TE label groupings - **/ + */ grouping te-label { description "This grouping defines the generic TE label. + The modeling structure can be augmented for each technology. + For unspecified technologies, 'rt-types:generalized-label' is used."; container te-label { description - "Container that specifies the TE label. The choices can - be augmented for specific data-plane technologies."; + "Container that specifies the TE label. + + The choices can be augmented for specific data-plane + technologies."; choice technology { default "generic"; description @@ -2201,34 +3127,38 @@ module ietf-te-types { default ""; description "When the datastore contains several topologies, - 'topology-id' distinguishes between them. If omitted, - the default (empty) string for this leaf is assumed."; + 'topology-id' distinguishes between them. + + If omitted, the default (empty) string for this leaf is + assumed."; } } } - /** + /* * TE performance metrics groupings - **/ + */ grouping performance-metrics-one-way-delay-loss { description "Performance Metrics (PM) information in real time that can - be applicable to links or connections. PM defined in this - grouping are applicable to generic TE PM as well as packet TE - PM."; + be applicable to links or connections. + + PM defined in this grouping are applicable to generic TE PM + as well as packet TE PM."; reference "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf one-way-delay { type uint32 { range "0..16777215"; } + units "microseconds"; description - "One-way delay or latency in microseconds."; + "One-way delay or latency."; } leaf one-way-delay-normality { type te-types:performance-metrics-normality; @@ -2239,21 +3169,24 @@ module ietf-te-types { grouping performance-metrics-two-way-delay-loss { description - "PM information in real time that can be applicable to links or - connections. PM defined in this grouping are applicable to - generic TE PM as well as packet TE PM."; + "Performance Metrics (PM) information in real time that can be + applicable to links or connections. + + PM defined in this grouping are applicable to generic TE PM + as well as packet TE PM."; reference "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf two-way-delay { type uint32 { range "0..16777215"; } + units "microseconds"; description - "Two-way delay or latency in microseconds."; + "Two-way delay or latency."; } leaf two-way-delay-normality { type te-types:performance-metrics-normality; @@ -2264,15 +3197,17 @@ module ietf-te-types { grouping performance-metrics-one-way-bandwidth { description - "PM information in real time that can be applicable to links. + "Performance Metrics (PM) information in real time that can be + applicable to links. + PM defined in this grouping are applicable to generic TE PM as well as packet TE PM."; reference "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf one-way-residual-bandwidth { type rt-types:bandwidth-ieee-float32; units "bytes per second"; @@ -2283,7 +3218,7 @@ module ietf-te-types { provides an aggregated remainder across QoS classes."; reference "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2"; + Version 2"; } leaf one-way-residual-bandwidth-normality { type te-types:performance-metrics-normality; @@ -2298,9 +3233,10 @@ module ietf-te-types { description "Available bandwidth that is defined to be residual bandwidth minus the measured bandwidth used for the - actual forwarding of non-RSVP-TE LSP packets. For a - bundled link, available bandwidth is defined to be the - sum of the component link available bandwidths."; + actual forwarding of non-RSVP-TE LSP packets. + + For a bundled link, available bandwidth is defined to be + the sum of the component link available bandwidths."; } leaf one-way-available-bandwidth-normality { type te-types:performance-metrics-normality; @@ -2328,14 +3264,21 @@ module ietf-te-types { grouping one-way-performance-metrics { description - "One-way PM throttle grouping."; + "One-way Performance Metrics (PM) throttle grouping."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions + RFC 7823: Performance-Based Path Selection for Explicitly + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf one-way-delay { type uint32 { range "0..16777215"; } + units "microseconds"; default "0"; description - "One-way delay or latency in microseconds."; + "One-way delay or latency."; } leaf one-way-residual-bandwidth { type rt-types:bandwidth-ieee-float32; @@ -2347,7 +3290,7 @@ module ietf-te-types { provides an aggregated remainder across QoS classes."; reference "RFC 3630: Traffic Engineering (TE) Extensions to OSPF - Version 2"; + Version 2"; } leaf one-way-available-bandwidth { type rt-types:bandwidth-ieee-float32; @@ -2356,9 +3299,10 @@ module ietf-te-types { description "Available bandwidth that is defined to be residual bandwidth minus the measured bandwidth used for the - actual forwarding of non-RSVP-TE LSP packets. For a - bundled link, available bandwidth is defined to be the - sum of the component link available bandwidths."; + actual forwarding of non-RSVP-TE LSP packets. + + For a bundled link, available bandwidth is defined to be + the sum of the component link available bandwidths."; } leaf one-way-utilized-bandwidth { type rt-types:bandwidth-ieee-float32; @@ -2374,14 +3318,21 @@ module ietf-te-types { grouping two-way-performance-metrics { description - "Two-way PM throttle grouping."; + "Two-way Performance Metrics (PM) throttle grouping."; + reference + "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions + RFC 7823: Performance-Based Path Selection for Explicitly + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf two-way-delay { type uint32 { range "0..16777215"; } + units "microseconds"; default "0"; description - "Two-way delay or latency in microseconds."; + "Two-way delay or latency."; } } @@ -2395,16 +3346,16 @@ module ietf-te-types { grouping performance-metrics-attributes { description - "Contains PM attributes."; + "Contains Performance Metrics (PM) attributes."; container performance-metrics-one-way { description "One-way link performance information in real time."; reference "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; uses performance-metrics-one-way-delay-loss; uses performance-metrics-one-way-bandwidth; } @@ -2413,14 +3364,14 @@ module ietf-te-types { "Two-way link performance information in real time."; reference "RFC 6374: Packet Loss and Delay Measurement for MPLS - Networks"; + Networks"; uses performance-metrics-two-way-delay-loss; } } grouping performance-metrics-throttle-container { description - "Controls PM throttling."; + "Controls Performance Metrics (PM) throttling."; container throttle { must 'suppression-interval >= measure-interval' { error-message "'suppression-interval' cannot be less than " @@ -2433,61 +3384,63 @@ module ietf-te-types { "Link performance information in real time."; reference "RFC 7471: OSPF Traffic Engineering (TE) Metric Extensions + RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions RFC 7823: Performance-Based Path Selection for Explicitly - Routed Label Switched Paths (LSPs) Using TE Metric - Extensions - RFC 8570: IS-IS Traffic Engineering (TE) Metric Extensions"; + Routed Label Switched Paths (LSPs) Using TE Metric + Extensions"; leaf one-way-delay-offset { type uint32 { range "0..16777215"; } + units "microseconds"; default "0"; description "Offset value to be added to the measured delay value."; } leaf measure-interval { type uint32; + units "seconds"; default "30"; description - "Interval, in seconds, to measure the extended metric - values."; + "Interval to measure the extended metric values."; } leaf advertisement-interval { type uint32; + units "seconds"; default "0"; description - "Interval, in seconds, to advertise the extended metric - values."; + "Interval to advertise the extended metric values."; } leaf suppression-interval { type uint32 { range "1..max"; } + units "seconds"; default "120"; description - "Interval, in seconds, to suppress advertisement of the - extended metric values."; + "Interval to suppress advertisement of the extended metric + values."; reference "RFC 8570: IS-IS Traffic Engineering (TE) Metric - Extensions, Section 6"; + Extensions, Section 6"; } container threshold-out { - uses performance-metrics-thresholds; description "If the measured parameter falls outside an upper bound for all but the minimum-delay metric (or a lower bound for the minimum-delay metric only) and the advertised value is not already outside that bound, an 'anomalous' announcement (anomalous bit set) will be triggered."; + uses performance-metrics-thresholds; } container threshold-in { - uses performance-metrics-thresholds; description "If the measured parameter falls inside an upper bound for all but the minimum-delay metric (or a lower bound for the minimum-delay metric only) and the advertised value is not already inside that bound, a 'normal' announcement (anomalous bit cleared) will be triggered."; + uses performance-metrics-thresholds; } container threshold-accelerated-advertisement { description @@ -2500,9 +3453,9 @@ module ietf-te-types { } } - /** + /* * TE tunnel generic groupings - **/ + */ grouping explicit-route-hop { description @@ -2512,9 +3465,25 @@ module ietf-te-types { "The explicit route entry type."; case numbered-node-hop { container numbered-node-hop { + must 'node-id-uri or node-id' { + description + "At least one node identifier needs to be present."; + } + description + "Numbered node route hop."; + reference + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.3, EXPLICIT_ROUTE in RSVP-TE + RFC 3477: Signalling Unnumbered Links in Resource + ReSerVation Protocol - Traffic Engineering + (RSVP-TE)"; + leaf node-id-uri { + type nw:node-id; + description + "The identifier of a node in the topology."; + } leaf node-id { type te-node-id; - mandatory true; description "The identifier of a node in the TE topology."; } @@ -2524,17 +3493,18 @@ module ietf-te-types { description "Strict or loose hop."; } - description - "Numbered node route hop."; - reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.3, EXPLICIT_ROUTE in RSVP-TE - RFC 3477: Signalling Unnumbered Links in Resource - ReSerVation Protocol - Traffic Engineering (RSVP-TE)"; } } case numbered-link-hop { container numbered-link-hop { + description + "Numbered link explicit route hop."; + reference + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.3, EXPLICIT_ROUTE in RSVP-TE + RFC 3477: Signalling Unnumbered Links in Resource + ReSerVation Protocol - Traffic Engineering + (RSVP-TE)"; leaf link-tp-id { type te-tp-id; mandatory true; @@ -2553,28 +3523,45 @@ module ietf-te-types { description "Link route object direction."; } - description - "Numbered link explicit route hop."; - reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.3, EXPLICIT_ROUTE in RSVP-TE - RFC 3477: Signalling Unnumbered Links in Resource - ReSerVation Protocol - Traffic Engineering (RSVP-TE)"; } } case unnumbered-link-hop { container unnumbered-link-hop { + must '(link-tp-id-uri or link-tp-id) and ' + + '(node-id-uri or node-id)' { + description + "At least one node identifier and at least one Link + Termination Point (LTP) identifier need to be + present."; + } + description + "Unnumbered link explicit route hop."; + reference + "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, + Section 4.3, EXPLICIT_ROUTE in RSVP-TE + RFC 3477: Signalling Unnumbered Links in Resource + ReSerVation Protocol - Traffic Engineering + (RSVP-TE)"; + leaf link-tp-id-uri { + type nt:tp-id; + description + "Link Termination Point (LTP) identifier."; + } leaf link-tp-id { type te-tp-id; - mandatory true; description - "TE LTP identifier. The combination of the TE link ID - and the TE node ID is used to identify an unnumbered - TE link."; + "TE LTP identifier. + + The combination of the TE link ID and the TE node ID + is used to identify an unnumbered TE link."; + } + leaf node-id-uri { + type nw:node-id; + description + "The identifier of a node in the topology."; } leaf node-id { type te-node-id; - mandatory true; description "The identifier of a node in the TE topology."; } @@ -2590,17 +3577,12 @@ module ietf-te-types { description "Link route object direction."; } - description - "Unnumbered link explicit route hop."; - reference - "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels, - Section 4.3, EXPLICIT_ROUTE in RSVP-TE - RFC 3477: Signalling Unnumbered Links in Resource - ReSerVation Protocol - Traffic Engineering (RSVP-TE)"; } } case as-number { container as-number-hop { + description + "Autonomous System (AS) explicit route hop."; leaf as-number { type inet:as-number; mandatory true; @@ -2613,18 +3595,43 @@ module ietf-te-types { description "Strict or loose hop."; } - description - "AS explicit route hop."; } } case label { + description + "The label explicit route hop type."; container label-hop { description "Label hop type."; uses te-label; } + } + } + } + + grouping explicit-route-hop-with-srlg { + description + "Augments the explicit route entry grouping with Shared Risk + Link Group (SRLG) hop type."; + uses explicit-route-hop { + augment "type" { description - "The label explicit route hop type."; + "Augmentation for a generic explicit route for Shared + Risk Link Group (SRLG) inclusion or exclusion."; + case srlg { + description + "An Shared Risk Link Group (SRLG) value to be + included or excluded."; + container srlg { + description + "Shared Risk Link Group (SRLG) container."; + leaf srlg { + type uint32; + description + "Shared Risk Link Group (SRLG) value."; + } + } + } } } } @@ -2635,20 +3642,33 @@ module ietf-te-types { leaf index { type uint32; description - "Record Route hop index. The index is used to - identify an entry in the list. The order of entries - is defined by the user without relying on key values."; + "Record Route hop index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without relying + on key values."; } choice type { description "The Record Route entry type."; case numbered-node-hop { + description + "Numbered node route hop."; container numbered-node-hop { + must 'node-id-uri or node-id' { + description + "At least one node identifier need to be present."; + } description "Numbered node route hop container."; + leaf node-id-uri { + type nw:node-id; + description + "The identifier of a node in the topology."; + } leaf node-id { type te-node-id; - mandatory true; description "The identifier of a node in the TE topology."; } @@ -2659,15 +3679,15 @@ module ietf-te-types { reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP - Tunnels + Tunnels RFC 4561: Definition of a Record Route Object (RRO) - Node-Id Sub-Object"; + Node-Id Sub-Object"; } } - description - "Numbered node route hop."; } case numbered-link-hop { + description + "Numbered link route hop."; container numbered-link-hop { description "Numbered link route hop container."; @@ -2684,23 +3704,46 @@ module ietf-te-types { reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP - Tunnels + Tunnels RFC 4561: Definition of a Record Route Object (RRO) - Node-Id Sub-Object"; + Node-Id Sub-Object"; } } - description - "Numbered link route hop."; } case unnumbered-link-hop { + description + "Unnumbered link route hop."; container unnumbered-link-hop { + must '(link-tp-id-uri or link-tp-id) and ' + + '(node-id-uri or node-id)' { + description + "At least one node identifier and at least one Link + Termination Point (LTP) identifier need to be + present."; + } + description + "Unnumbered link Record Route hop."; + reference + "RFC 3477: Signalling Unnumbered Links in Resource + ReSerVation Protocol - Traffic Engineering + (RSVP-TE)"; + leaf link-tp-id-uri { + type nt:tp-id; + description + "Link Termination Point (LTP) identifier."; + } leaf link-tp-id { type te-tp-id; - mandatory true; description - "TE LTP identifier. The combination of the TE link ID - and the TE node ID is used to identify an unnumbered - TE link."; + "TE LTP identifier. + + The combination of the TE link ID and the TE node ID + is used to identify an unnumbered TE link."; + } + leaf node-id-uri { + type nw:node-id; + description + "The identifier of a node in the topology."; } leaf node-id { type te-node-id; @@ -2714,20 +3757,15 @@ module ietf-te-types { reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP - Tunnels + Tunnels RFC 4561: Definition of a Record Route Object (RRO) - Node-Id Sub-Object"; + Node-Id Sub-Object"; } - description - "Unnumbered link Record Route hop."; - reference - "RFC 3477: Signalling Unnumbered Links in Resource - ReSerVation Protocol - Traffic Engineering (RSVP-TE)"; } - description - "Unnumbered link route hop."; } case label { + description + "The label Record Route entry types."; container label-hop { description "Label route hop type."; @@ -2739,13 +3777,11 @@ module ietf-te-types { reference "RFC 3209: RSVP-TE: Extensions to RSVP for LSP Tunnels RFC 4090: Fast Reroute Extensions to RSVP-TE for LSP - Tunnels + Tunnels RFC 4561: Definition of a Record Route Object (RRO) - Node-Id Sub-Object"; + Node-Id Sub-Object"; } } - description - "The label Record Route entry types."; } } } @@ -2797,7 +3833,8 @@ module ietf-te-types { must "(not(../label-start/te-label/direction) and" + " not(te-label/direction))" + " or " - + "(../label-start/te-label/direction = te-label/direction)" + + "(../label-start/te-label/direction = " + + "te-label/direction)" + " or " + "(not(te-label/direction) and" + " (../label-start/te-label/direction = 'forward'))" @@ -2815,10 +3852,13 @@ module ietf-te-types { container label-step { description "The step increment between labels in the label range. - The label start/end values will have to be consistent - with the sign of label step. For example, - 'label-start' < 'label-end' enforces 'label-step' > 0 - 'label-start' > 'label-end' enforces 'label-step' < 0."; + + The label start/end values MUST be consistent with the sign + of label step. + + For example: + 'label-start' < 'label-end' enforces 'label-step' > 0 + 'label-start' > 'label-end' enforces 'label-step' < 0."; choice technology { default "generic"; description @@ -2838,17 +3878,31 @@ module ietf-te-types { description "When there are gaps between 'label-start' and 'label-end', this attribute is used to specify the positions - of the used labels. This is represented in big endian as - 'hex-string'. + of the used labels. + + This is represented in big endian as 'hex-string'. + + In case the restriction is 'inclusive', the bit-position is + set if the corresponding mapped label is available. + In this case, if the range-bitmap is not present, all the + labels in the range are available. + + In case the restriction is 'exclusive', the bit-position is + set if the corresponding mapped label is not available. + In this case, if the range-bitmap is not present, all the + labels in the range are not available. + The most significant byte in the hex-string is the farthest - to the left in the byte sequence. Leading zero bytes in the - configured value may be omitted for brevity. + to the left in the byte sequence. + + Leading zero bytes in the configured value may be omitted + for brevity. + Each bit position in the 'range-bitmap' 'hex-string' maps to a label in the range derived from 'label-start'. For example, assuming that 'label-start' = 16000 and 'range-bitmap' = 0x01000001, then: - - bit position (0) is set, and the corresponding mapped label from the range is 16000 + (0 * 'label-step') or 16000 for default 'label-step' = 1. @@ -2873,7 +3927,7 @@ module ietf-te-types { labels are available."; reference "RFC 7579: General Network Element Constraint Encoding - for GMPLS-Controlled Networks"; + for GMPLS-Controlled Networks"; uses label-restriction-info; } } @@ -2884,7 +3938,7 @@ module ietf-te-types { "Optimization metrics configuration grouping."; leaf metric-type { type identityref { - base path-metric-type; + base path-metric-optimization-type; } description "Identifies the 'metric-type' that the path computation @@ -2930,7 +3984,8 @@ module ietf-te-types { in the computed path."; reference "RFC 4202: Routing Extensions in Support of - Generalized Multi-Protocol Label Switching (GMPLS)"; + Generalized Multi-Protocol Label Switching + (GMPLS)"; } leaf setup-priority { type uint8 { @@ -2966,6 +4021,11 @@ module ietf-te-types { description "Tunnel constraints grouping that can be set on a constraint set or directly on the tunnel."; + leaf network-id { + type nw:network-id; + description + "The network topology identifier."; + } uses te-topology-identifier; uses common-constraints; } @@ -2974,9 +4034,9 @@ module ietf-te-types { description "List of route entries to be included or excluded when performing the path computation."; - container explicit-route-objects-always { + container explicit-route-objects { description - "Container for the 'exclude route' object list."; + "Container for the explicit route object lists."; list route-object-exclude-always { key "index"; ordered-by user; @@ -2986,11 +4046,27 @@ module ietf-te-types { leaf index { type uint32; description - "Explicit Route Object index. The index is used to - identify an entry in the list. The order of entries - is defined by the user without relying on key values."; + "Explicit Route Object index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without + relying on key values."; + } + uses explicit-route-hop { + refine "type/numbered-node-hop/numbered-node-hop" + + "/hop-type" { + must '. = "strict"' { + description + "Loose hops can only be used for 'include' route + objects."; + reference + "RFC 4874: Exclude Routes - Extension to Resource + ReserVation Protocol-Traffic Engineering + (RSVP-TE), Section 3.1"; + } + } } - uses explicit-route-hop; } list route-object-include-exclude { key "index"; @@ -3005,33 +4081,34 @@ module ietf-te-types { default "te-types:route-include-object"; description "Indicates whether to include or exclude the - route object. The default is to include it."; + route object. + + The default is to include it."; } leaf index { type uint32; description - "Route object include-exclude index. The index is used - to identify an entry in the list. The order of entries - is defined by the user without relying on key values."; + "Route object include-exclude index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without + relying on key values."; } - uses explicit-route-hop { - augment "type" { - case srlg { - container srlg { - description - "SRLG container."; - leaf srlg { - type uint32; - description - "SRLG value."; - } - } + uses explicit-route-hop-with-srlg { + refine "type/numbered-node-hop/numbered-node-hop" + + "/hop-type" { + must '(. = "strict") or ' + + 'derived-from-or-self(../../explicit-route-usage,' + + '"te-types:route-include-object")' { description - "An SRLG value to be included or excluded."; + "Loose hops can only be used for 'include' route + objects."; + reference + "RFC 4874: Exclude Routes - Extension to Resource + ReserVation Protocol-Traffic Engineering + (RSVP-TE), Section 3.1"; } - description - "Augmentation for a generic explicit route for SRLG - exclusion."; } } } @@ -3051,9 +4128,12 @@ module ietf-te-types { leaf index { type uint32; description - "Route object entry index. The index is used to - identify an entry in the list. The order of entries - is defined by the user without relying on key values."; + "Route object entry index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without + relying on key values."; } uses explicit-route-hop; } @@ -3072,30 +4152,14 @@ module ietf-te-types { leaf index { type uint32; description - "Route object entry index. The index is used to - identify an entry in the list. The order of entries - is defined by the user without relying on key values."; - } - uses explicit-route-hop { - augment "type" { - case srlg { - container srlg { - description - "SRLG container."; - leaf srlg { - type uint32; - description - "SRLG value."; - } - } - description - "An SRLG value to be included or excluded."; - } - description - "Augmentation for a generic explicit route for SRLG - exclusion."; - } + "Route object entry index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without + relying on key values."; } + uses explicit-route-hop-with-srlg; } } @@ -3104,14 +4168,22 @@ module ietf-te-types { "TE path metric bounds grouping."; container path-metric-bounds { description - "TE path metric bounds container."; + "Top-level container for the list of path metric bounds."; list path-metric-bound { key "metric-type"; description - "List of TE path metric bounds."; + "List of path metric bounds, which can apply to link and + path metrics. + + TE paths which have at least one path metric which + exceeds the specified bounds MUST NOT be selected. + + TE paths that traverse TE links which have at least one + link metric which exceeds the specified bounds MUST NOT + be selected."; leaf metric-type { type identityref { - base path-metric-type; + base link-path-metric-type; } description "Identifies an entry in the list of 'metric-type' items @@ -3121,9 +4193,13 @@ module ietf-te-types { type uint64; default "0"; description - "Upper bound on the end-to-end TE path metric. A zero - indicates an unbounded upper limit for the specific - 'metric-type'."; + "Upper bound on the specified 'metric-type'. + + A zero indicates an unbounded upper limit for the + specified 'metric-type'. + + The unit of is interpreted in the context of the + 'metric-type' identity."; } } } @@ -3150,10 +4226,15 @@ module ietf-te-types { } /* Tiebreakers */ container tiebreakers { + status deprecated; description - "Container for the list of tiebreakers."; + "Container for the list of tiebreakers. + + This container has been deprecated by the tiebreaker + leaf."; list tiebreaker { key "tiebreaker-type"; + status deprecated; description "The list of tiebreaker criteria to apply on an equally favored set of paths, in order to pick @@ -3162,6 +4243,7 @@ module ietf-te-types { type identityref { base path-metric-type; } + status deprecated; description "Identifies an entry in the list of tiebreakers."; } @@ -3187,6 +4269,15 @@ module ietf-te-types { } } } + leaf tiebreaker { + type identityref { + base path-tiebreaker-type; + } + default "te-types:path-tiebreaker-random"; + description + "The tiebreaker criteria to apply on an equally favored set + of paths, in order to pick the best."; + } } grouping generic-path-affinities { @@ -3211,7 +4302,9 @@ module ietf-te-types { type admin-groups; default ""; description - "The affinity value. The default is empty."; + "The affinity value. + + The default is empty."; } } } @@ -3232,13 +4325,13 @@ module ietf-te-types { } list affinity-name { key "name"; + description + "List of named affinities."; leaf name { type string; description "Identifies a named affinity entry."; } - description - "List of named affinities."; } } } @@ -3246,48 +4339,51 @@ module ietf-te-types { grouping generic-path-srlgs { description - "Path SRLG grouping."; + "Path Shared Risk Link Group (SRLG) grouping."; container path-srlgs-lists { description - "Path SRLG properties container."; + "Path Shared Risk Link Group (SRLG) properties container."; list path-srlgs-list { key "usage"; description - "List of SRLG values to be included or excluded."; + "List of Shared Risk Link Group (SRLG) values to be + included or excluded."; leaf usage { type identityref { base route-usage-type; } description - "Identifies an entry in a list of SRLGs to either - include or exclude."; + "Identifies an entry in a list of Shared Risk Link Groups + (SRLGs) to either include or exclude."; } leaf-list values { type srlg; description - "List of SRLG values."; + "List of Shared Risk Link Group (SRLG) values."; } } } container path-srlgs-names { description - "Container for the list of named SRLGs."; + "Container for the list of named Shared Risk Link Groups + (SRLGs)."; list path-srlgs-name { key "usage"; description - "List of named SRLGs to be included or excluded."; + "List of named Shared Risk Link Groups (SRLGs) to be + included or excluded."; leaf usage { type identityref { base route-usage-type; } description - "Identifies an entry in a list of named SRLGs to either - include or exclude."; + "Identifies an entry in a list of named Shared Risk Link + Groups (SRLGs) to either include or exclude."; } leaf-list names { type string; description - "List of named SRLGs."; + "List of named Shared Risk Link Groups (SRLGs)."; } } } @@ -3301,9 +4397,10 @@ module ietf-te-types { description "The type of resource disjointness. When configured for a primary path, the disjointness level - applies to all secondary LSPs. When configured for a - secondary path, the disjointness level overrides the level - configured for the primary path."; + applies to all secondary LSPs. + + When configured for a secondary path, the disjointness + level overrides the level configured for the primary path."; } } @@ -3366,14 +4463,79 @@ module ietf-te-types { leaf index { type uint32; description - "Route object entry index. The index is used to - identify an entry in the list. The order of entries - is defined by the user without relying on key - values."; + "Route object entry index. + + The index is used to identify an entry in the list. + + The order of entries is defined by the user without + relying on key values."; } uses explicit-route-hop; } } } } + + grouping encoding-and-switching-type { + description + "Common grouping to define the LSP encoding and + switching types"; + leaf encoding { + type identityref { + base te-types:lsp-encoding-types; + } + description + "LSP encoding type."; + reference + "RFC 3945: Generalized Multi-Protocol Label Switching (GMPLS) + Architecture"; + } + leaf switching-type { + type identityref { + base te-types:switching-capabilities; + } + description + "LSP switching type."; + reference + "RFC 3945: Generalized Multi-Protocol Label Switching (GMPLS) + Architecture"; + } + } + + grouping te-generic-node-id { + description + "A reusable grouping for a TE generic node identifier."; + leaf id { + type union { + type te-node-id; + type inet:ip-address; + type nw:node-id; + } + description + "The identifier of the node. + + It can be represented as IP address or dotted quad address + or as a URI. + + The type data node disambiguates the union type."; + } + leaf type { + type enumeration { + enum ip { + description + "IP address representation of the node identifier."; + } + enum te-id { + description + "TE identifier of the node"; + } + enum node-id { + description + "URI representation of the node identifier."; + } + } + description + "Type of node identifier representation."; + } + } }