module huawei-rsvp-interface {

    yang-version 1;

    namespace
      "urn:huawei:yang:huawei-rsvp-interface";

    prefix rsvp-interface;

    import huawei-extension {
      prefix ext;
    }
    import huawei-pub-type {
      prefix pub-type;
    }
    import huawei-network-instance {
      prefix ni;
    }
    import huawei-ifm {
      prefix ifm;
    }
    import huawei-mpls {
      prefix mpls;
    }
    import huawei-mpls-te {
      prefix mpls-te;
    }
    import huawei-te-interface {
      prefix te-interface;
    }
    import huawei-te {
      prefix te;
    }

    include huawei-rsvp-interface-type;

    organization
      "Huawei Technologies Co., Ltd.";

    contact
      "Huawei Industrial Base
Bantian, Longgang
Shenzhen 518129
People's Republic of China
Website: http://www.huawei.com
Email: support@huawei.com";

    description
      "Specifies the traffic engineering configuration.";

    revision "2020-07-11" {
      description
        "Add private syntax to the keychain name.";
      reference
        "Huawei private.";

    }

    revision "2020-03-10" {
      description
        "Fixed some nodes condition.";
      reference
        "Huawei private.";

    }

    revision "2019-07-29" {
      description "Init revision.";
      reference
        "Huawei private.";

    }

    ext:task-name "mpls-te";

    rpc reset-rsvp-te-statistics {
      ext:node-ref "/ni:network-instance/ni:instances/ni:instance/mpls:mpls/mpls-te:te/rsvp-interface:rsvp-interfaces/rsvp-interface:rsvp-interface";
      description
        "To clear RSVP TE statistics.";
      input {
        leaf name {
          type leafref {
            path "/ifm:ifm/ifm:interfaces/ifm:interface/ifm:name";
          }
          description
            "Name of the RSVP interface of which the statistics are recollected. The name is case-insensitive.";
        }
      }
    }  // rpc reset-rsvp-te-statistics

    augment /ni:network-instance/ni:instances/ni:instance/mpls:mpls/mpls-te:te {
      description
        "TE Configuration information augment to network instance.";
      container rsvp-interfaces {
        when
          "/mpls:mpls/mpls-te:te/mpls-te:rsvp/mpls-te:enable='true'";
        description
          "List of RSVP interface configuration.";
        list rsvp-interface {
          must
            "../../../../te:te/te-interface:interfaces/te-interface:interface[te-interface:name=current()/name]/te-interface:mpls-te-enable='true'";
          must
            "/ifm:ifm/ifm:interfaces/ifm:interface[ifm:name=current()/name]/ifm:vrf-name='_public_'";
          key "name";
          description
            "Configure RSVP interface.";
          leaf name {
            type leafref {
              path
                "/ifm:ifm/ifm:interfaces/ifm:interface/ifm:name";
            }
            description
              "Interface name. The name is case-insensitive.";
          }

          leaf hello-enable {
            when
              "/mpls:mpls/mpls-te:te/mpls-te:rsvp/mpls-te:global/mpls-te:hello-enable='true'";
            type boolean;
            default "false";
            description
              "Enable/disable Hello function.";
          }

          leaf graceful-shutdown-enable {
            type boolean;
            default "false";
            description
              "Enable/disable graceful shutdown for interface.";
          }

          leaf srefresh-compatible-enable {
            type boolean;
            default "false";
            description
              "Enable/disable summary refresh feature for interface.";
          }

          leaf auto-frr-mode {
            type frr-mode-type;
            config false;
            description
              "Auto FRR protection modes.";
          }

          leaf distribute-inst-name {
            ext:operation-exclude "update|delete";
            type leafref {
              path "/mpls:mpls/mpls-te:te/mpls-te:rsvp/mpls-te:distribute-instances/mpls-te:distribute-instance/mpls-te:instance-name";
            }
            default "RSVP0";
            description
              "Name of RSVP distributed instance.";
          }

          container authentication {
            description
              "Configure neighbor of RSVP TE authentication.";
            leaf enable {
              type boolean;
              default "false";
              description
                "Enable/disable the state of RSVP TE interface authentication.";
            }

            leaf type {
              when "../enable='true'";
              type rsvp-authentication-type;
              mandatory true;
              description
                "Authentication type on an RSVP-TE interface.";
            }

            leaf keychain-name {
              ext:case-sensitivity "lower-only";
              when
                "../enable='true' and ../type='keychain'";
              type string {
                length "1..47";
                pattern '[^A-Z]+';
              }
              mandatory true;
              description
                "Keychain name. The name is case insensitive.";
            }

            leaf md5-key {
              when
                "../enable='true' and ../type!='keychain'";
              type pub-type:password-extend {
                pattern '[^ ]+';
              }
              mandatory true;
              description
                "Authentication key of an RSVP TE interface. When the key is configured, the RSVP packets that the interface sends out carry the authentication information that are calculated based on the authentication key by using the MD5 algorithm. The packets the interface receives are also verified based on the authentication key. The two ends of a TE link must be configured with the same authentication key, otherwise, RSVP packets cannot pass through the link. The password is a string ranging from 1 to 255 characters for a simple text password and 20 to 432 characters for a ciphertext password.";
            }

            leaf life-time {
              when "../enable='true'";
              type pub-type:time-tick {
                range "1..86399";
              }
              units "s";
              default "1800";
              description
                "Authentication lifetime. During authentication lifetime, RSVP authentication lifetime will be reset after a RSVP packet is received. If no RSVP packet is received when the authentication lifetime times out, the RSVP neighbor will delete the authentication relationship to prevent persistent authentication.";
            }

            leaf handshake-enable {
              when "../enable='true'";
              type boolean;
              default "false";
              description
                "Enable/disable the handshake authentication. When RSVP packet authentication is out of order, a handshake will be initiated and authentication will be re-negotiated.";
            }

            leaf window-size {
              when
                "../enable='true' and ../handshake-enable='true'";
              type uint32 {
                range "1..64";
              }
              default "1";
              description
                "Size of an authentication window that is set to prevent information loss caused by packet disorder. If the packet sequence number exceeds the window size, the packet is considered to be out of order.";
            }
          }  // container authentication

          container statistics {
            config false;
            description
              "RSVP Interface statistics.";
            leaf psb-count {
              type uint32;
              description
                "Number of path state blocks.";
            }

            leaf rsb-count {
              type uint32;
              description
                "Number of reservation state blocks.";
            }

            leaf psb-cleanup-timeout-count {
              type uint32;
              description
                "Number of times for cleaning up the PSB that times out.";
            }

            leaf rsb-cleanup-timeout-count {
              type uint32;
              description
                "Number of times for cleaning up the RSB that times out.";
            }

            leaf send-packet-count {
              type uint32;
              description
                "Number of sent RSVP signaling packets.";
            }

            leaf receive-packet-count {
              type uint32;
              description
                "Number of received RSVP signaling packets.";
            }

            leaf send-path-count {
              type uint32;
              description
                "Number of sent Path packets. The Path packets are sent from the upstream node to the downstream node.";
            }

            leaf receive-path-count {
              type uint32;
              description
                "Number of received Path packets. The Path packets are sent from the upstream node to the downstream node.";
            }

            leaf send-refresh-path-count {
              type uint32;
              description
                "Number of sent refresh Path packets. The Path packets are sent from the upstream node to the downstream node.";
            }

            leaf receive-refresh-path-count {
              type uint32;
              description
                "Number of received refresh Path packets. The Path packets are sent from the upstream node to the downstream node.";
            }

            leaf send-resv-count {
              type uint32;
              description
                "Number of sent Resv packets.";
            }

            leaf receive-resv-count {
              type uint32;
              description
                "Number of received Resv packets.";
            }

            leaf send-refresh-resv-count {
              type uint32;
              description
                "Number of sent refresh Resv packets.";
            }

            leaf receive-refresh-resv-count {
              type uint32;
              description
                "Number of received refresh Resv packets.";
            }

            leaf send-resv-conf-count {
              type uint32;
              description
                "Number of sent ResvConf packets.";
            }

            leaf receive-resv-conf-count {
              type uint32;
              description
                "Number of received ResvConf packets.";
            }

            leaf send-hello-count {
              type uint32;
              description
                "Number of sent Hello packets.";
            }

            leaf receive-hello-count {
              type uint32;
              description
                "Number of received Hello packets.";
            }

            leaf send-ack-count {
              type uint32;
              description
                "Number of sent Ack packets.";
            }

            leaf receive-ack-count {
              type uint32;
              description
                "Number of received Ack packets.";
            }

            leaf send-path-error-count {
              type uint32;
              description
                "Number of sent PathErr packets.";
            }

            leaf receive-path-error-count {
              type uint32;
              description
                "Number of received PathErr packets.";
            }

            leaf send-resv-error-count {
              type uint32;
              description
                "Number of sent ResvErr packets.";
            }

            leaf receive-resv-error-count {
              type uint32;
              description
                "Number of received ResvErr packets.";
            }

            leaf send-path-tear-count {
              type uint32;
              description
                "Number of sent PathTear packets.";
            }

            leaf receive-path-tear-count {
              type uint32;
              description
                "Number of received PathTear packets.";
            }

            leaf send-resv-tear-count {
              type uint32;
              description
                "Number of sent ResvTear packets.";
            }

            leaf receive-resv-tear-count {
              type uint32;
              description
                "Number of received ResvTear packets.";
            }

            leaf send-srefresh-count {
              type uint32;
              description
                "Number of sent Srefresh packets.";
            }

            leaf receive-srefresh-count {
              type uint32;
              description
                "Number of received Srefresh packets.";
            }

            leaf send-ack-msg-count {
              type uint32;
              description
                "Number of sent Msg_ID_ACK packets.";
            }

            leaf receive-ack-msg-count {
              type uint32;
              description
                "Number of received Msg_ID_ACK packets.";
            }

            leaf send-challenge-msg-count {
              type uint32;
              description
                "Number of sent Challenge packets.";
            }

            leaf receive-challenge-msg-count {
              type uint32;
              description
                "Number of received Challenge packets.";
            }

            leaf send-response-msg-count {
              type uint32;
              description
                "Number of sent response packets.";
            }

            leaf receive-response-msg-count {
              type uint32;
              description
                "Number of received response packets.";
            }

            leaf send-error-msg-count {
              type uint32;
              description
                "Number of sent Msg_ID_NACK packets.";
            }

            leaf receive-error-msg-count {
              type uint32;
              description
                "Number of received Msg_ID_NACK packets.";
            }

            leaf send-recovery-path-msg-count {
              type uint32;
              description
                "Number of sent Path packets. The Path packets are sent from the downstream node to the upstream node.";
            }

            leaf receive-recovery-path-msg-count {
              type uint32;
              description
                "Number of received Path packets. The Path packets are sent from the downstream node to the upstream node.";
            }

            leaf send-gr-path-msg-count {
              type uint32;
              description
                "Number of sent GRPath packets.";
            }

            leaf receive-gr-path-msg-count {
              type uint32;
              description
                "Number of received GRPath packets.";
            }

            leaf send-notify-msg-count {
              type uint32;
              description
                "Number of send notify packets.";
            }

            leaf receive-notify-msg-count {
              type uint32;
              description
                "Number of receive notify packets.";
            }

            leaf resource-fault-count {
              type uint32;
              description
                "Number of resource request fault packets.";
            }

            leaf neighbor-count {
              type uint32;
              description
                "Number of RSVP neighbor.";
            }

            leaf bfd-session-count {
              type uint32;
              description
                "Number of BFD session.";
            }

            leaf retransmit-packet-count {
              type uint32;
              description
                "Number of resend RSVP packets.";
            }

            leaf response-packet-count {
              type uint32;
              description
                "Number of ack packets for resend.";
            }

            leaf retransmit-path-count {
              type uint32;
              description
                "Number of resend Path packets.";
            }

            leaf response-path-count {
              type uint32;
              description
                "Number of ack packets for Path resend.";
            }

            leaf retransmit-resv-count {
              type uint32;
              description
                "Number of resend Resv packets.";
            }

            leaf response-resv-count {
              type uint32;
              description
                "Number of ack packets for Resv resend.";
            }

            leaf retransmit-resv-conf-count {
              type uint32;
              description
                "Number of resend ResvConf packets.";
            }

            leaf response-resv-conf-count {
              type uint32;
              description
                "Number of ack packets for ResvConf resend.";
            }

            leaf retransmit-path-error-count {
              type uint32;
              description
                "Number of resend PathErr packets.";
            }

            leaf response-path-error-count {
              type uint32;
              description
                "Number of ack packets for PathErr resend.";
            }

            leaf retransmit-resv-error-count {
              type uint32;
              description
                "Number of resend ResvErr packets.";
            }

            leaf response-resv-error-count {
              type uint32;
              description
                "Number of ack packets for ResvErr resend.";
            }

            leaf retransmit-path-tear-count {
              type uint32;
              description
                "Number of resend PathTear packets.";
            }

            leaf response-path-tear-count {
              type uint32;
              description
                "Number of ack packets for PathTear resend.";
            }

            leaf retransmit-resv-tear-count {
              type uint32;
              description
                "Number of resend ResvTear packets.";
            }

            leaf response-resv-tear-count {
              type uint32;
              description
                "Number of ack packets for ResvTear resend.";
            }

            leaf retransmit-srefresh-count {
              type uint32;
              description
                "Number of resend srefresh packets.";
            }

            leaf response-srefresh-count {
              type uint32;
              description
                "Number of ack packets for srefresh resend.";
            }

            leaf retransmit-recovery-path-msg-count {
              type uint32;
              description
                "Number of resend recovery path packets.";
            }

            leaf response-recovery-path-msg-count {
              type uint32;
              description
                "Number of ack packets for recovery path resend.";
            }

            leaf retransmit-gr-path-msg-count {
              type uint32;
              description
                "Number of resend GRPath packets.";
            }

            leaf response-gr-path-msg-count {
              type uint32;
              description
                "Number of ack packets for GRPath resend.";
            }

            leaf retransmit-notify-msg-count {
              type uint32;
              description
                "Number of resend Notify packets.";
            }

            leaf response-notify-msg-count {
              type uint32;
              description
                "Number of ack packets for Notify resend.";
            }
          }  // container statistics
        }  // list rsvp-interface
      }  // container rsvp-interfaces
    }
  }  // module huawei-rsvp-interface