module ietf-rift {

    yang-version 1.1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-rift";

    prefix rift;

    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-routing {
      prefix rt;
      reference
        "RFC 8349: A YANG Data Model for Routing Management
        (NMDA Version)";


    }
    import ietf-interfaces {
      prefix if;
      reference
        "RFC 8343: A YANG Data Model for Interface Management";


    }
    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-key-chain {
      prefix key-chain;
      reference
        "RFC 8177: YANG Data Model for Key Chains";


    }

    organization
      "IETF RIFT (Routing In Fat Trees) Working Group";

    contact
      "WG Web:   <https://datatracker.ietf.org/wg/rift/>
     WG List:  <mailto:rift@ietf.org>

     Author:   Zheng (Sandy) Zhang
               <mailto:zhang.zheng@zte.com.cn>

     Author:   Yuehua Wei
               <mailto:wei.yuehua@zte.com.cn>

     Author:   Shaowen Ma
               <mailto:mashaowen@gmail.com>

     Author:   Xufeng Liu
               <mailto:xufeng.liu.ietf@gmail.com>

     Author:   Bruno Rijsman
               <mailto:brunorijsman@gmail.com>";

    description
      "This YANG module defines the generic configuration and
     operational state for the RIFT protocol common to all
     vendor implementations.  It is intended that the module
     will be extended by vendors to define vendor-specific
     RIFT configuration parameters and policies --
     for example, route maps or route policies.

     Copyright (c) 2025 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 9719
     (https://www.rfc-editor.org/info/rfc9719); see the RFC itself
     for full legal notices.

     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.";

    revision "2025-04-04" {
      description "Initial revision.";
      reference
        "RFC 9719: YANG Data Model for Routing in Fat Trees
        (RIFT).";

    }


    feature nonce-delta-adjust {
      description
        "Support weak nonce delta adjusting that is used in
       security.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees.
        Section 6.9.";

    }

    feature label-switching {
      description
        "Support label switching for instance distinguishing.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees.
        Section 6.8.8";

    }

    feature tie-security {
      description
        "Support security function for the TIE exchange.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees.
        Section 6.9.3.";

    }

    feature link-security {
      description
        "Support security function of link.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees.
        Section 6.9.";

    }

    typedef system-id {
      type string {
        pattern
          '[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}';
      }
      description
        "This type defines the pattern for RIFT System IDs.
       An example of a System ID is 0021.2FFF.FEB5.6E10.";
    }

    typedef level {
      type uint8 {
        range "0 .. 24";
      }
      default "0";
      description
        "The value of node level.
       Clos and Fat Tree networks are topologically partially
       ordered graphs and 'level' denotes the set of nodes at
       the same height in such a network.
       Nodes at the top level (i.e., ToF) are at the level with
       the highest value and count down to the nodes
       at the bottom level (i.e., leaf) with the lowest value.
       In RIFT, level 0 always indicates that a node is a leaf,
       but does not have to be level 0.
       Level values can be configured manually or automatically
       derived.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees.
        Section 6.7.";

    }

    typedef ieee802-1as-timestamp {
      type uint64;
      units "seconds";
      description
        "Timestamp per IEEE802.1AS. It is advertised with prefix
       to achieve mobility.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees. Section 6.8.4.
        IEEE8021AS: Timing and Synchronization for Time-Sensitive
        	    Applications in Bridged Local Area Networks";

    }

    identity rift {
      base rt:routing-protocol;
      description
        "Identity for the RIFT routing protocol.";
      reference
        "RFC 9692: RIFT: Routing in Fat Trees";

    }

    notification error-set {
      description
        "The errors notification of RIFT.";
      container tie-level-error {
        description
          "The TIE errors notification of RIFT.";
        list rift {
          key "name";
          description "The TIE errors set.";
          leaf name {
            type string;
            description
              "The RIFT instance's name.";
          }

          list ties {
            key "originator";
            description
              "The level is undefined in the LIEs.";
            leaf tie-direction-type {
              type enumeration {
                enum "illegal" {
                  value 0;
                  description
                    "Illegal direction.";
                }
                enum "south" {
                  value 1;
                  description
                    "The direction to a node one level down.";
                }
                enum "north" {
                  value 2;
                  description
                    "The direction to a node one level up.";
                }
                enum "max" {
                  value 3;
                  description
                    "The max value of direction.";
                }
              }
              config false;
              description
                "The direction type of TIE.";
            }

            leaf originator {
              type system-id;
              description
                "The originator's system-id of this TIE.";
            }

            leaf tie-type {
              type enumeration {
                enum "illegal" {
                  value 0;
                  description
                    "The illegal TIE.";
                }
                enum "min-tie-type" {
                  value 1;
                  description
                    "The minimum TIE.";
                }
                enum "node" {
                  value 2;
                  description
                    "The node TIE.";
                }
                enum "prefix" {
                  value 3;
                  description
                    "The prefix TIE.";
                }
                enum
                  "positive-disaggregation-prefix" {
                  value 4;
                  description
                    "The positive disaggregation prefix TIE.";
                }
                enum
                  "negative-disaggregation-prefix" {
                  value 5;
                  description
                    "The negative disaggregation prefix TIE.";
                }
                enum "pgp-prefix" {
                  value 6;
                  description
                    "The policy guide prefix TIE.";
                }
                enum "key-value" {
                  value 7;
                  description
                    "The key value TIE.";
                }
                enum "external-prefix" {
                  value 8;
                  description
                    "The external prefix TIE.";
                }
                enum
                  "positive-external-disaggregation-prefix" {
                  value 9;
                  description
                    "The positive external disaggregation prefix TIE.";
                }
                enum "max-tie-type" {
                  value 10;
                  description
                    "The maximum TIE.";
                }
              }
              description
                "The types of TIE.";
            }

            leaf tie-number {
              type uint32;
              description
                "The number of this TIE.";
            }

            leaf seq {
              type uint64;
              description
                "The sequence number of a TIE.";
              reference
                "RFC 9692: RIFT: Routing in Fat Trees.
                Section 6.3.1.";

            }

            leaf size {
              type uint32;
              description
                "The size of this TIE.";
            }

            leaf origination-time {
              type ieee802-1as-timestamp;
              description
                "Absolute timestamp when the TIE was generated.
This can be used on fabrics with synchronized
clock to prevent lifetime modification attacks.";
            }

            leaf origination-lifetime {
              type uint32;
              units "seconds";
              description
                "Original lifetime when the TIE was generated.
This can be used on fabrics with synchronized clock
to prevent lifetime modification attacks.";
            }

            leaf remaining-lifetime {
              type uint32;
              units "seconds";
              description
                "The remaining lifetime of the TIE.";
            }
          }  // list ties
        }  // list rift
      }  // container tie-level-error

      container neighbor-error {
        description
          "The neighbor errors notification of RIFT.";
        list rift {
          key "name";
          description "The RIFT instance.";
          leaf name {
            type string;
            description
              "The RIFT instance's name.";
          }

          list interfaces {
            key "name";
            description
              "The interfaces with wrong level neighbor.";
            leaf link-id {
              type uint32;
              description
                "The local id of this interface.";
            }

            leaf name {
              type if:interface-ref;
              description
                "The interface's name.";
            }

            list neighbors {
              key "system-id";
              description
                "The level of the neighbor is wrong.";
              leaf system-id {
                type system-id;
                description
                  "Each node is identified via a system-id which is 64
                 bits wide.";
              }

              leaf node-level {
                type level;
                description
                  "The level of this node.";
              }
            }  // list neighbors
          }  // list interfaces
        }  // list rift
      }  // container neighbor-error
    }  // notification error-set
  }  // module ietf-rift