Cisco-IOS-XR-ip-tcp-oper-sub1

This submodule contains a collection of YANG definitions for Cisco IOS-XR ip-tcp package operational data. Copyright (c) 2013-2...

  • Version: 2020-05-15

    Cisco-IOS-XR-ip-tcp-oper-sub1@2020-05-15


    
      submodule Cisco-IOS-XR-ip-tcp-oper-sub1 {
    
        yang-version 1;
    
        belongs-to Cisco-IOS-XR-ip-tcp-oper {
            prefix Cisco-IOS-XR-ip-tcp-oper;
        }
    
        import ietf-inet-types {
          prefix inet;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
         Customer Service
         
         Postal: 170 West Tasman Drive
         San Jose, CA 95134
         
         Tel: +1 800 553-NETS
         
         E-mail: cs-yang@cisco.com";
    
        description
          "This submodule contains a collection of YANG definitions
         for Cisco IOS-XR ip-tcp package operational data.
         
         Copyright (c) 2013-2020 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2020-05-15" {
          description
            "First SYN delay timer added";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2018-11-01" {
          description
            "Added socket async double free prevention count in tcp statistics summary";
        }
    
        revision "2018-02-14" {
          description
            "PCB_ID argument is passed in string format.";
        }
    
        revision "2018-02-14" {
          description
            "Added support for TCP-AO feature.";
        }
    
        revision "2017-05-01" {
          description
            "Fixing backward compatibility error in module.";
        }
    
        revision "2016-02-26" {
          description "Descriptions updated.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "1.1.0";
        semver:module-version "1.0.0";
    
        typedef Nsr-down-reason {
          type enumeration {
            enum "none" {
              value 0;
              description
                "None, i.e. NSR was never up";
            }
            enum "init-sync-aborted" {
              value 1;
              description
                "Initial sync was aborted";
            }
            enum "client-disabled" {
              value 2;
              description
                "Disabled by Active APP";
            }
            enum "client-disconnect" {
              value 3;
              description
                "Standby APP disconnected";
            }
            enum "tcp-disconnect" {
              value 4;
              description
                "Standby TCP disconnected";
            }
            enum "failover" {
              value 5;
              description
                "RP/DRP Failover occurred";
            }
            enum "nsr-clear" {
              value 6;
              description "Clear nsr command";
            }
            enum "internal-error" {
              value 7;
              description
                "Internal error occurred";
            }
            enum "retransmit-threshold-exceed" {
              value 8;
              description
                "Retransmission threshold exceededprobably
               becauseS-TCP was not healthy";
            }
            enum
              "init-sync-failure-thresh-exceeded" {
              value 9;
              description
                "Init-sync repeat failures have exceeded
               threshold";
            }
            enum "audit-timeout" {
              value 10;
              description
                "Audit operation timed out";
            }
            enum "audit-failed" {
              value 11;
              description
                "Audit operation failed";
            }
            enum "standby-sscb-deleted" {
              value 12;
              description "Standby SSCB deleted";
            }
            enum "standby-session-close" {
              value 13;
              description
                "Session was closed on standby";
            }
            enum "standby-rxpath-frozen" {
              value 14;
              description
                "RX-Path was frozen on standby";
            }
            enum "partner-deleted" {
              value 15;
              description
                "Partner was deleted from set";
            }
          }
          description "NSR-Down Reasons";
        }
    
        typedef Nsr-status {
          type enumeration {
            enum "down" {
              value 0;
              description "NSR Stream Down";
            }
            enum "up" {
              value 1;
              description "NSR Stream Up";
            }
            enum "na" {
              value 2;
              description
                "NSR Stream Not applicable";
            }
          }
          description "NSR Stream Status";
        }
    
        typedef Addr-family {
          type enumeration {
            enum "internetwork" {
              value 2;
              description
                "Internetwork: UDP, TCP, etc.";
            }
            enum "ip-version6" {
              value 10;
              description "IP version 6";
            }
          }
          description "Address Family Types";
        }
    
        grouping TCP-NSR-PCB-STATS-BAG {
          description
            "SSO/NSR statistics of a TCP connection";
          container snd-counters {
            description
              "Send path counters for the PCB";
            uses TCP-NSR-SND-COUNTERS-NODE;
          }  // container snd-counters
    
          leaf pcb {
            type uint64;
            description "PCB Address";
          }
    
          leaf number-of-times-nsr-up {
            type uint32;
            description
              "no. of times nsr went up";
          }
    
          leaf number-of-timers-nsr-down {
            type uint32;
            description
              "no. of times nsr went down";
          }
    
          leaf number-of-times-nsr-disabled {
            type uint32;
            description
              "no. of times nsr was disabled";
          }
    
          leaf number-of-times-nsr-fail-over {
            type uint32;
            description
              "no. of times fail-over occured";
          }
    
          leaf internal-ack-drops-not-replicated {
            type uint64;
            description
              "Number of iACKs dropped because session is not
             replicated";
          }
    
          leaf internal-ack-drops-initsync-first-phase {
            type uint64;
            description
              "Number of iACKs dropped because 1st phase of
             init-sync is in progress";
          }
    
          leaf internal-ack-drops-stale {
            type uint64;
            description
              "Number of stale iACKs dropped";
          }
    
          leaf internal-ack-drops-immediate-match {
            type uint64;
            description
              "Number of iACKs not held because of an immediate
             match";
          }
    
          leaf last-cleared-time {
            type uint32;
            units "second";
            description
              "Time of last clear (in seconds since 1st Jan
             1970 00:00:00)";
          }
        }  // grouping TCP-NSR-PCB-STATS-BAG
    
        grouping TCP-NSR-SSCB-STATS-BAG {
          description
            "SSO/NSR statistics of a Session Set";
          leaf sscb {
            type uint64;
            description "SSCB Address";
          }
    
          leaf set-id {
            type uint32;
            description "ID of this Session-set";
          }
    
          leaf number-of-attempted-init-sync {
            type uint32;
            description
              "no. of initial-sync attempts";
          }
    
          leaf number-of-succeeded-init-sync {
            type uint32;
            description
              "no. of initial-sync successes";
          }
    
          leaf number-of-failed-init-sync {
            type uint32;
            description
              "no. of initial-sync failures";
          }
    
          leaf number-of-failover {
            type uint32;
            description "Number of Switch-overs";
          }
    
          leaf number-of-nsr-resets {
            type uint32;
            description
              "Number of times NSR was reset for the session";
          }
    
          leaf last-cleared-time {
            type uint32;
            units "second";
            description
              "Time of last clear (in seconds since 1st Jan
             1970 00:00:00)";
          }
        }  // grouping TCP-NSR-SSCB-STATS-BAG
    
        grouping TCP-NSR-CCB-STATS-BAG {
          description
            "SSO/NSR statistics of a Client";
          leaf ccb {
            type uint64;
            description
              "Address of the Client Control Block";
          }
    
          leaf pid {
            type uint32;
            description "PID of the Client";
          }
    
          leaf process-name {
            type string;
            description "Proc name of Clinet";
          }
    
          leaf job-id {
            type int32;
            description "JOb ID of Client";
          }
    
          leaf instance {
            type uint32;
            description "Instance of the Client";
          }
    
          leaf connected-at {
            type uint32;
            units "second";
            description
              "Time of connect (in seconds since 1st Jan 1970
             00:00:00)";
          }
    
          leaf number-of-created-sscb {
            type uint32;
            description
              "Num of created session sets";
          }
    
          leaf number-of-deleted-sscb {
            type uint32;
            description
              "Num of deleted session sets";
          }
    
          leaf last-cleared-time {
            type uint32;
            units "second";
            description
              "Time of last clear (in seconds since 1st Jan
             1970 00:00:00)";
          }
    
          list notification-statistic {
            description
              "Various types of notification stats";
            uses TSS-NOTIF-STATS;
          }  // list notification-statistic
        }  // grouping TCP-NSR-CCB-STATS-BAG
    
        grouping TCP-NSR-AUDIT-COUNTERS-AGGR-ONLY-NODE {
          description
            "Aggregate-only counters for NSR audit";
          leaf mark-session-set-rcv-drop-aggr {
            type uint32;
            description
              "Number of session-set Mark messages dropped by
             standby";
          }
    
          leaf session-rcv-drop-aggr {
            type uint32;
            description
              "Number of session audit messages dropped by
             standby";
          }
    
          leaf sweep-session-set-rcv-drop-aggr {
            type uint32;
            description
              "Number of session-set Sweep messages dropped by
             standby";
          }
    
          leaf session-set-response-rcv-drop-aggr {
            type uint32;
            description
              "Number of session-set response messages dropped
             by active";
          }
    
          leaf mark-session-set-ack-rcv-drop-aggr {
            type uint32;
            description
              "Number of session-set mark ack messages dropped
             by active";
          }
    
          leaf mark-session-set-nack-rcv-drop-aggr {
            type uint32;
            description
              "Number of session-set mark nack messages dropped
             by active";
          }
        }  // grouping TCP-NSR-AUDIT-COUNTERS-AGGR-ONLY-NODE
    
        grouping TCP-NSR-AUDIT-COUNTERS-NODE {
          description "Audit counters";
          leaf mark-session-set-send {
            type uint32;
            description
              "Number of successful session-set Mark's sent by
             active";
          }
    
          leaf mark-session-set-send-drop {
            type uint32;
            description
              "Number of failed session-set Mark's";
          }
    
          leaf mark-session-set-rcv {
            type uint32;
            description
              "Number of successful session-set Mark's received
             by standby";
          }
    
          leaf mark-session-set-rcv-drop {
            type uint32;
            description
              "Number of session-set Mark's dropped by standby";
          }
    
          leaf session-send {
            type uint32;
            description
              "Number of successful session audits sent by
             active";
          }
    
          leaf session-send-drop {
            type uint32;
            description
              "Number of session audits that couldn't be sent
             by active";
          }
    
          leaf session-rcv {
            type uint32;
            description
              "Number of session audits received by standby";
          }
    
          leaf session-rcv-drop {
            type uint32;
            description
              "Number of session audits dropped by standby";
          }
    
          leaf sweep-session-set-send {
            type uint32;
            description
              "Number of successful session-set Sweep's sent by
             active";
          }
    
          leaf sweep-session-set-send-drop {
            type uint32;
            description
              "Number of failed session-set Sweep's";
          }
    
          leaf sweep-session-set-rcv {
            type uint32;
            description
              "Number of successful session-set Sweep's
             received by standby";
          }
    
          leaf sweep-session-set-rcv-drop {
            type uint32;
            description
              "Number of session-set Sweep's dropped by standby";
          }
    
          leaf session-set-response-send {
            type uint32;
            description
              "Number of successful audit responses sent by
             standby";
          }
    
          leaf session-set-response-send-drop {
            type uint32;
            description
              "Number of audit responses that couldn't be sent
             by standby";
          }
    
          leaf session-set-response-rcv {
            type uint32;
            description
              "Number of audit responses received by active";
          }
    
          leaf session-set-response-rcv-drop {
            type uint32;
            description
              "Number of audit responses dropped by active";
          }
    
          leaf mark-session-set-ack-send {
            type uint32;
            description
              "Number of successful audit mark acks sent by
             standby";
          }
    
          leaf mark-session-set-ack-send-drop {
            type uint32;
            description
              "Number of audit mark acks that couldn't be sent
             by standby";
          }
    
          leaf mark-session-set-ack-rcv {
            type uint32;
            description
              "Number of audit mark acks received by active";
          }
    
          leaf mark-session-set-ack-rcv-drop {
            type uint32;
            description
              "Number of audit mark acks dropped by active";
          }
    
          leaf mark-session-set-nack-send {
            type uint32;
            description
              "Number of successful audit mark nacks sent by
             standby";
          }
    
          leaf mark-session-set-nack-send-drop {
            type uint32;
            description
              "Number of audit mark nacks that couldn't be sent
             by standby";
          }
    
          leaf mark-session-set-nack-rcv {
            type uint32;
            description
              "Number of audit mark nacks received by active";
          }
    
          leaf mark-session-set-nack-rcv-drop {
            type uint32;
            description
              "Number of audit mark nacks dropped by active";
          }
    
          leaf abort {
            type uint32;
            description
              "Number of times the active aborted an audit
             session";
          }
        }  // grouping TCP-NSR-AUDIT-COUNTERS-NODE
    
        grouping TCP-NSR-AUDIT-COUNTERS-AGGR-NODE {
          description
            "Aggregate counters for NSR audit";
          container common {
            description "Common audit counters";
            uses TCP-NSR-AUDIT-COUNTERS-NODE;
          }  // container common
    
          container aggr-only {
            description
              "Aggregate only audit counters";
            uses TCP-NSR-AUDIT-COUNTERS-AGGR-ONLY-NODE;
          }  // container aggr-only
        }  // grouping TCP-NSR-AUDIT-COUNTERS-AGGR-NODE
    
        grouping TCP-NSR-SND-COUNTERS-AGGR-ONLY-NODE {
          description
            "Send path aggregate only counters";
          leaf data-xfer-rcv-drop-no-pcb {
            type uint32;
            description
              "Number of Data transfer messages dropped because
             PCB wasn't found";
          }
    
          leaf data-xfer-rcv-drop-no-scb-dp {
            type uint32;
            description
              "Number of Data transfer messages dropped because
             SCB DP wasn't found";
          }
    
          leaf seg-instr-rcv-drop-no-pcb {
            type uint32;
            description
              "Number of Segmentation instruction messages
             dropped because PCB wasn't found";
          }
    
          leaf seg-instr-rcv-drop-no-scb-dp {
            type uint32;
            description
              "Number of Segmentation instruction messages
             dropped because SCB DP wasn't found";
          }
    
          leaf nack-rcv-drop-no-pcb {
            type uint32;
            description
              "Number of NACK messages dropped because PCB
             wasn't found";
          }
    
          leaf nack-rcv-drop-no-scb-dp {
            type uint32;
            description
              "Number of NACK messages dropped because SCB DP
             wasn't found";
          }
    
          leaf cleanup-rcv-drop-no-pcb {
            type uint32;
            description
              "Number of Cleanup messages dropped because PCB
             wasn't found";
          }
    
          leaf cleanup-rcv-drop-no-scb-dp {
            type uint32;
            description
              "Number of Cleanup messages dropped because SCB
             DP wasn't found";
          }
        }  // grouping TCP-NSR-SND-COUNTERS-AGGR-ONLY-NODE
    
        grouping TCP-NSR-SND-COUNTERS-NODE {
          description "Send path counters";
          leaf data-xfer-send {
            type uint32;
            description
              "Number of successful DATA transfers";
          }
    
          leaf data-xfer-send-total {
            type uint64;
            description
              "Amount of data transferred";
          }
    
          leaf data-xfer-send-drop {
            type uint32;
            description
              "Number of failed DATA transfers";
          }
    
          leaf data-xfer-send-iov-alloc {
            type uint32;
            description
              "Number of data transfer msgs., that required new
             IOV's to be allocated";
          }
    
          leaf data-xfer-rcv {
            type uint32;
            description
              "Number of received DATA transfers";
          }
    
          leaf data-xfer-rcv-success {
            type uint32;
            description
              "Number of successfully received DATA transfers";
          }
    
          leaf data-xfer-rcv-fail-buffer-trim {
            type uint32;
            description
              "Number of received DATA transfers that had
             buffer trim failures";
          }
    
          leaf data-xfer-rcv-fail-snd-una-out-of-sync {
            type uint32;
            description
              "Number of received DATA transfers that had
             failures because the send path was out of sync";
          }
    
          leaf seg-instr-send {
            type uint32;
            description
              "Number of successful Segmentation instruction
             messages";
          }
    
          leaf seg-instr-send-units {
            type uint32;
            description
              "Number of segement units transferred via the
             successful Segmentation instruction messages";
          }
    
          leaf seg-instr-send-drop {
            type uint32;
            description
              "Number of failed Segmentation instruction
             messages";
          }
    
          leaf seg-instr-rcv {
            type uint32;
            description
              "Number of received Segmentation instruction
             messages";
          }
    
          leaf seg-instr-rcv-success {
            type uint32;
            description
              "Number of successfully received Segmentation
             instruction messages";
          }
    
          leaf seg-instr-rcv-fail-buffer-trim {
            type uint32;
            description
              "Number of received Segmentation instructions
             that had buffer trim failures";
          }
    
          leaf seg-instr-rcv-fail-tcp-process {
            type uint32;
            description
              "Number of received Segmentation instructions
             that had failures during TCP processing";
          }
    
          leaf nack-send {
            type uint32;
            description
              "Number of successful NACK messages";
          }
    
          leaf nack-send-drop {
            type uint32;
            description
              "Number of failed NACK messages";
          }
    
          leaf nack-rcv {
            type uint32;
            description
              "Number of received NACK messages";
          }
    
          leaf nack-rcv-success {
            type uint32;
            description
              "Number of successfully received NACK messages";
          }
    
          leaf nack-rcv-fail-data-send {
            type uint32;
            description
              "Number of received NACK messages that had
             failures when sending data in response to the
             NACK";
          }
    
          leaf cleanup-send {
            type uint32;
            description
              "Number of successful Cleanup messages";
          }
    
          leaf cleanup-send-drop {
            type uint32;
            description
              "Number of failed Cleanup messages";
          }
    
          leaf cleanup-rcv {
            type uint32;
            description
              "Number of received Cleanup messages";
          }
    
          leaf cleanup-rcv-success {
            type uint32;
            description
              "Number of successfully received Cleanup messages";
          }
    
          leaf cleanup-rcv-fail-buffer-trim {
            type uint32;
            description
              "Number of Cleanup messages that had trim
             failures";
          }
        }  // grouping TCP-NSR-SND-COUNTERS-NODE
    
        grouping TCP-NSR-SND-COUNTERS-AGGR-NODE {
          description
            "Send path aggregate counters";
          container common {
            description
              "Common send path counters";
            uses TCP-NSR-SND-COUNTERS-NODE;
          }  // container common
    
          container aggr-only {
            description
              "Aggregate only send path counters";
            uses TCP-NSR-SND-COUNTERS-AGGR-ONLY-NODE;
          }  // container aggr-only
        }  // grouping TCP-NSR-SND-COUNTERS-AGGR-NODE
    
        grouping TSS-NOTIF-STATS {
          description
            "notif stats structure used in ccb stats bag";
          leaf queued-count {
            type uint32;
            description "how many were queued";
          }
    
          leaf failed-count {
            type uint32;
            description
              "Errors while queuing the notifs";
          }
    
          leaf delivered-count {
            type uint32;
            description
              "How many were picked up by app?";
          }
    
          leaf dropped-count {
            type uint32;
            description
              "How many were dropped because of timeout";
          }
        }  // grouping TSS-NOTIF-STATS
    
        grouping TCP-NSR-SUMMARY-STATS-BAG {
          description
            "Summary SSO/NSR statistics";
          container snd-counters {
            description
              "Aggregate Send path counters";
            uses TCP-NSR-SND-COUNTERS-AGGR-NODE;
          }  // container snd-counters
    
          container audit-counters {
            description
              "Aggregate Audit counters";
            uses TCP-NSR-AUDIT-COUNTERS-AGGR-NODE;
          }  // container audit-counters
    
          leaf last-cleared-time {
            type uint32;
            units "second";
            description
              "Time of last clear (in seconds since 1st Jan
             1970 00:00:00)";
          }
    
          leaf number-of-connected-clients {
            type uint32;
            description
              "Number of disconnected clients";
          }
    
          leaf number-of-disconnected-clients {
            type uint32;
            description
              "Number of disconnected clients";
          }
    
          leaf number-of-current-clients {
            type uint32;
            description
              "Number of current  clients";
          }
    
          leaf number-of-created-session-sets {
            type uint32;
            description
              "Number of created session sets";
          }
    
          leaf number-of-destroyed-session-sets {
            type uint32;
            description
              "Number of destroyed session sets";
          }
    
          leaf number-of-current-session-sets {
            type uint32;
            description
              "Number of current session sets";
          }
    
          leaf number-of-added-sessions {
            type uint32;
            description
              "Number of added sessions";
          }
    
          leaf number-of-deleted-sessions {
            type uint32;
            description
              "Number of deleted sessions";
          }
    
          leaf number-of-current-sessions {
            type uint32;
            description
              "Number of current sessions";
          }
    
          leaf number-of-partner-node {
            type uint32;
            description
              " Number of Parner Nodes";
          }
    
          leaf number-of-attempted-init-sync {
            type uint32;
            description
              "no. of initial-sync attempts";
          }
    
          leaf number-of-succeeded-init-sync {
            type uint32;
            description
              "no. of initial-sync successes";
          }
    
          leaf number-of-failed-init-sync {
            type uint32;
            description
              "no. of initial-sync fails";
          }
    
          leaf number-of-held-packets {
            type uint32;
            description
              "Number of Packets held by Active TCP";
          }
    
          leaf number-of-held-but-dropped-packets {
            type uint32;
            description
              "Number of held packets dropped by Active TCP";
          }
    
          leaf number-of-held-internal-acks {
            type uint32;
            description
              "Number of Internal Acks held by Active TCP";
          }
    
          leaf number-of-held-but-dropped-internal-acks {
            type uint32;
            description
              "Number of held Internal Acks dropped by Active
             TCP";
          }
    
          leaf number-of-sent-internal-acks {
            type uint32;
            description
              "Number of Internal Acks sent to Active TCP by
             Standby TCP";
          }
    
          leaf number-of-received-internal-acks {
            type uint32;
            description
              "Number of Internal Acks received by Active TCP";
          }
    
          leaf number-of-qad-receive-messages-drops {
            type uint32;
            description
              "Number of dropped messages from partner TCP
             stack(s)";
          }
    
          leaf number-of-qad-receive-messages-unknowns {
            type uint32;
            description
              "Number of unknown messages from partner TCP
             stack(s)";
          }
    
          leaf number-of-qad-receive-messages-accepts {
            type uint32;
            description
              "Number of messages accepted from partner TCP
             stack(s)";
          }
    
          leaf number-of-qad-stale-receive-messages-drops {
            type uint32;
            description
              "Number of dropped messages from partner TCP
             stack(s) because they were out-of-order";
          }
    
          leaf number-of-qad-transfer-message-sent {
            type uint32;
            description
              "Number of messages sent to partner TCP stack(s)";
          }
    
          leaf number-of-qad-transfer-message-drops {
            type uint32;
            description
              "Number of messages failed to be sent to partner
             TCP stack(s)";
          }
    
          leaf number-of-internal-ack-drops-no-pcb {
            type uint32;
            description
              "Number of iACKs dropped because there is no PCB";
          }
    
          leaf number-of-internal-ack-drops-no-scbdp {
            type uint32;
            description
              "Number of iACKs dropped because there is no
             datapath SCB";
          }
    
          leaf internal-ack-drops-not-replicated {
            type uint32;
            description
              "Number of iACKs dropped because session is not
             replicated";
          }
    
          leaf internal-ack-drops-initsync-first-phase {
            type uint32;
            description
              "Number of iACKs dropped because init-sync is in
             1st phase";
          }
    
          leaf internal-ack-drops-stale {
            type uint32;
            description
              "Number of stale iACKs dropped";
          }
    
          leaf internal-ack-drops-immediate-match {
            type uint32;
            description
              "Number of iACKs not held because of an immediate
             match";
          }
    
          leaf held-packet-drops {
            type uint32;
            description
              "Number of held packets dropped because of errors";
          }
    
          list notification-statistic {
            description
              "Various types of notification stats";
            uses TSS-NOTIF-STATS;
          }  // list notification-statistic
        }  // grouping TCP-NSR-SUMMARY-STATS-BAG
    
        grouping TCP-NSR-SSCB-DETAILED-BAG {
          description
            "Detailed Information about an SSO/NSR Session-set";
          leaf sscb {
            type uint64;
            description
              "Address of the Session Set Control Block";
          }
    
          leaf pid {
            type uint32;
            description
              "PID of the Client that owns this Session-set";
          }
    
          leaf set-id {
            type uint32;
            description "ID of this Session-set";
          }
    
          leaf sso-role {
            type uint32;
            description "TCP role for this set?";
          }
    
          leaf mode {
            type uint32;
            description "Session-set mode";
          }
    
          leaf address-family {
            type Addr-family;
            description
              "Address Family of the sessions in this set";
          }
    
          leaf well-known-port {
            type uint16;
            description
              "Well Known Port of the client";
          }
    
          leaf local-node {
            type xr:Node-id;
            description "Local node of this set";
          }
    
          leaf local-instance {
            type uint32;
            description
              "Instance of the client application on the local
             node";
          }
    
          leaf protect-node {
            type xr:Node-id;
            description
              "The node protecting this set";
          }
    
          leaf protect-instance {
            type uint32;
            description
              "Instance of the client application on the
             protection node";
          }
    
          leaf number-of-sessions {
            type uint32;
            description
              "Number of Sessions in the set";
          }
    
          leaf number-of-synced-sessions-up-stream {
            type uint32;
            description
              "How many sessions are synced with upstream
             partner";
          }
    
          leaf number-of-synced-sessions-down-stream {
            type uint32;
            description
              "How many sessions are synced with downstream
             partner";
          }
    
          leaf is-init-sync-in-progress {
            type boolean;
            description
              "Is an initial sync in progress currently?";
          }
    
          leaf is-init-sync-second-phase {
            type boolean;
            description
              "Is initial sync in the second phase?";
          }
    
          leaf sequence-number-of-init-sync {
            type uint32;
            description
              "ID of the current or the last initial sync
             operation";
          }
    
          leaf init-sync-timer {
            type uint32;
            description
              "Time left on the initial sync timer";
          }
    
          leaf total-number-of-init-sync-sessions {
            type uint32;
            description
              "Number of sessions being synced as part of the
             current initial sync operation";
          }
    
          leaf number-of-init-synced-sessions {
            type uint32;
            description
              "Number of sessions that are synced as part of
             the current initial sync operation";
          }
    
          leaf number-of-sessions-init-sync-failed {
            type uint32;
            description
              "Number of sessions that failed to sync as part
             of the current initial sync operation";
          }
    
          leaf init-sync-error {
            type string;
            description
              "Initial sync failure reason, if any";
          }
    
          leaf is-init-sync-error-local {
            type boolean;
            description
              "Initial sync failed due to a local error or
             remote stack";
          }
    
          leaf init-sync-start-time {
            type uint32;
            units "second";
            description
              "Time at which last or current initial sync
             operation was started (in seconds since 1st Jan
             1970 00:00:00)";
          }
    
          leaf init-sync-end-time {
            type uint32;
            units "second";
            description
              "Time at which the last initial sync operation
             was ended (in seconds since 1st Jan 1970 00:00
             :00)";
          }
    
          leaf is-sscb-init-sync-ready {
            type boolean;
            description
              "Is the SSCB ready for another initial sync?";
          }
    
          leaf init-sync-ready-start-time {
            type uint32;
            units "second";
            description
              "Time at which the session was ready for initial
             sync last (in seconds since 1st Jan 1970 00:00
             :00)";
          }
    
          leaf init-sync-ready-end-time {
            type uint32;
            units "second";
            description
              "Time at which the session set last went
             not-ready for initial sync (in seconds since 1st
             Jan 1970 00:00:00)";
          }
    
          leaf nsr-reset-time {
            type uint32;
            units "second";
            description
              "Time at which NSR was last reset on the session
             set (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf is-audit-in-progress {
            type boolean;
            description
              "Is an audit in progress currently?";
          }
    
          leaf audit-seq-number {
            type uint32;
            description
              "ID of the current or the last audit operation";
          }
    
          leaf audit-start-time {
            type uint32;
            units "second";
            description
              "Time at which last or current audit operation
             was started (in seconds since 1st Jan 1970 00:00
             :00)";
          }
    
          leaf audit-end-time {
            type uint32;
            units "second";
            description
              "Time at which the last audit operation was ended
             (in seconds since 1st Jan 1970 00:00:00)";
          }
        }  // grouping TCP-NSR-SSCB-DETAILED-BAG
    
        grouping TCP-NSR-CCB-BRIEF-BAG {
          description
            "Summary Information about an SSO/NSR Client";
          leaf ccb {
            type uint64;
            description
              "Address of the Client Control Block";
          }
    
          leaf pid {
            type uint32;
            description "PID of the Client";
          }
    
          leaf process-name {
            type string;
            description "Proc name of Clinet";
          }
    
          leaf job-id {
            type int32;
            description "JOb ID of Client";
          }
    
          leaf instance {
            type uint32;
            description "Instance of the Client";
          }
    
          leaf numberof-sets {
            type uint32;
            description
              "Number of Sets owned by this client ";
          }
    
          leaf number-of-sessions {
            type uint32;
            description
              "Number of sessions owned by this client ";
          }
    
          leaf number-of-up-sessions {
            type uint32;
            description
              "Number of sessions with NSR up ";
          }
        }  // grouping TCP-NSR-CCB-BRIEF-BAG
    
        grouping TCP-NSR-CCB-DETAILED-BAG {
          description
            "Detailed Information about an SSO/NSR Client";
          leaf ccb {
            type uint64;
            description
              "Address of the Client Control Block";
          }
    
          leaf pid {
            type uint32;
            description "PID of the Client";
          }
    
          leaf process-name {
            type string;
            description "Proc name of Clinet";
          }
    
          leaf job-id {
            type int32;
            description "JOb ID of Client";
          }
    
          leaf instance {
            type uint32;
            description "Instance of the Client";
          }
    
          leaf numberof-sets {
            type uint32;
            description
              "Number of Sets owned by this client ";
          }
    
          leaf number-of-sessions {
            type uint32;
            description
              "Number of sessions owned by this client ";
          }
    
          leaf number-of-up-sessions {
            type uint32;
            description
              "Number of sessions with NSR up";
          }
    
          leaf connected-at {
            type uint32;
            units "second";
            description
              "Time of connect (in seconds since 1st Jan 1970
             00:00:00)";
          }
    
          leaf is-notification-registered {
            type boolean;
            description
              "Registered with TCP for notifications?";
          }
        }  // grouping TCP-NSR-CCB-DETAILED-BAG
    
        grouping TCP-NSR-HOLD-QUEUE-NODE {
          description
            "Info about the Packet or iACK held";
          leaf sequence-number {
            type uint32;
            description "Sequence Number";
          }
    
          leaf data-length {
            type uint32;
            description "Data Length";
          }
    
          leaf acknoledgement-number {
            type uint32;
            description "Ack Number";
          }
        }  // grouping TCP-NSR-HOLD-QUEUE-NODE
    
        grouping TCP-NSR-SSCB-BRIEF-BAG {
          description
            "Summary Information about an SSO/NSR Session-set";
          leaf sscb {
            type uint64;
            description
              "Address of the Session Set Control Block";
          }
    
          leaf pid {
            type uint32;
            description
              "PID of the Client that owns this Session-set";
          }
    
          leaf client-name {
            type string;
            description
              "the name of Clinet that owns this Session-set";
          }
    
          leaf client-instance {
            type uint32;
            description
              "Instance of the Client that owns this
             Session-set";
          }
    
          leaf set-id {
            type uint32;
            description "ID of this Session-set";
          }
    
          leaf sso-role {
            type uint32;
            description "TCP role for this set?";
          }
    
          leaf mode {
            type uint32;
            description "Session-set mode";
          }
    
          leaf address-family {
            type Addr-family;
            description
              "Address Family of the sessions in this set";
          }
    
          leaf well-known-port {
            type uint16;
            description
              "Well Known Port of the client";
          }
    
          leaf local-node {
            type xr:Node-id;
            description "Local node of this set";
          }
    
          leaf local-instance {
            type uint32;
            description
              "Instance of the client application on the local
             node";
          }
    
          leaf protect-node {
            type xr:Node-id;
            description
              "The node protecting this set";
          }
    
          leaf protect-instance {
            type uint32;
            description
              "Instance of the client application on the
             protection node";
          }
    
          leaf number-of-sessions {
            type uint32;
            description
              "Number of Sessions in the set";
          }
    
          leaf number-of-synced-sessions-up-stream {
            type uint32;
            description
              "How many sessions are synced with upstream
             partner";
          }
    
          leaf number-of-synced-sessions-down-stream {
            type uint32;
            description
              "How many sessions are synced with downstream
             partner";
          }
    
          leaf is-init-sync-in-progress {
            type boolean;
            description
              "Is an initial sync in progress currently?";
          }
    
          leaf is-sscb-init-sync-ready {
            type boolean;
            description
              "Is the SSCB ready for another initial sync?";
          }
        }  // grouping TCP-NSR-SSCB-BRIEF-BAG
    
        grouping TCP-NSR-PCB-DETAILED-BAG {
          description
            "Detailed SSO/NSR information about a TCP
           connection";
          container set-information {
            description "Sesson-set information";
            uses TCP-NSR-SSCB-BRIEF-BAG;
          }  // container set-information
    
          leaf address-family {
            type Addr-family;
            description "Address family";
          }
    
          leaf pcb {
            type uint64;
            description "PCB Address";
          }
    
          leaf sscb {
            type uint64;
            description "SSCB Address";
          }
    
          leaf local-port {
            type uint16;
            description "Local port";
          }
    
          leaf foreign-port {
            type uint16;
            description "Foreign port";
          }
    
          leaf vrf-id {
            type uint32;
            description "VRF Id";
          }
    
          leaf is-admin-configured-up {
            type boolean;
            description
              "Is NSR administratively configured?";
          }
    
          leaf is-us-operational-up {
            type Nsr-status;
            description
              "Is Upstream NSR operational?";
          }
    
          leaf is-ds-operational-up {
            type Nsr-status;
            description
              "Is Downstream NSR operational?";
          }
    
          leaf is-only-receive-path-replication {
            type boolean;
            description
              "Is replication limited to receive-path only";
          }
    
          leaf cookie {
            type uint64;
            description
              "Cookie provided by active APP";
          }
    
          leaf is-session-replicated {
            type boolean;
            description
              "Has the session been replicated to standby?";
          }
    
          leaf is-session-synced {
            type boolean;
            description
              "Has the session completed initial-sync?";
          }
    
          leaf fist-standby-sequence-number {
            type uint32;
            description
              "If initial sync is completed, then the FSSN -
             First Standby Sequence Number";
          }
    
          leaf fssn-offset {
            type uint32;
            description
              "Offset of FSSN in input stream";
          }
    
          leaf nsr-down-reason {
            type Nsr-down-reason;
            description
              "If NSR is not up, the reason for it.";
          }
    
          leaf nsr-down-time {
            type uint32;
            description
              "Time at which NSR went down";
          }
    
          leaf sequence-number-of-init-sync {
            type uint32;
            description
              "ID of the Initial sync operation";
          }
    
          leaf is-init-sync-in-progress {
            type boolean;
            description
              "Is initial-sync currently in progress?";
          }
    
          leaf is-init-sync-second-phase {
            type boolean;
            description
              "Is initial sync in the second phase?";
          }
    
          leaf init-sync-error {
            type string;
            description
              "Initial sync failure reason, if any";
          }
    
          leaf is-init-sync-error-local {
            type boolean;
            description
              "Initial sync failed due to a local error or
             remote stack";
          }
    
          leaf init-sync-start-time {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             started (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf init-sync-end-time {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             ended (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf init-sync-flags {
            type uint32;
            description
              "Init Sync flags for the session";
          }
    
          leaf sequence-number-of-init-sync-up-stream {
            type uint32;
            description
              "ID of the Initial sync operation";
          }
    
          leaf peer-endp-hdl-up-stream {
            type uint64;
            description "Peer NCD endp handle";
          }
    
          leaf init-sync-start-time-up-stream {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             started (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf init-sync-end-time-up-stream {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             ended (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf fist-standby-sequence-number-up-stream {
            type uint32;
            description
              "FSSN for the upstream partner";
          }
    
          leaf nsr-down-reason-up-stream {
            type Nsr-down-reason;
            description
              "The reason NSR is not up towards the upstream
             partner";
          }
    
          leaf nsr-down-time-up-stream {
            type uint32;
            description
              "Time at which NSR went down";
          }
    
          leaf sequence-number-of-init-sync-down-stream {
            type uint32;
            description
              "ID of the Initial sync operation";
          }
    
          leaf peer-endp-hdl-down-stream {
            type uint64;
            description "Peer NCD endp handle";
          }
    
          leaf init-sync-start-time-down-stream {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             started (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf init-sync-end-time-down-stream {
            type uint32;
            units "second";
            description
              "Time at which the initial sync operation was
             ended (in seconds since 1st Jan 1970 00:00:00)";
          }
    
          leaf fist-standby-sequence-number-down-stream {
            type uint32;
            description
              "FSSN for the upstream partner";
          }
    
          leaf nsr-down-reason-down-stream {
            type Nsr-down-reason;
            description
              "The reason NSR is not up towards the upstream
             partner";
          }
    
          leaf nsr-down-time-down-stream {
            type uint32;
            description
              "Time at which NSR went down";
          }
    
          leaf max-number-of-held-packet {
            type int32;
            description
              "Max number of incoming packets have been held";
          }
    
          leaf max-number-of-held-packet-reach-time {
            type uint32;
            description
              "Max number of held incoming packets reaches at";
          }
    
          leaf max-number-of-held-internal-ack {
            type int32;
            description
              "Max number of internal acks have been held";
          }
    
          leaf max-number-of-held-internal-ack-reach-time {
            type uint32;
            description
              "Max number of held internal acks reaches at";
          }
    
          list local-address {
            max-elements 4;
            description "Local address";
            leaf entry {
              type inet:ipv4-address;
              description "Local address";
            }
          }  // list local-address
    
          list foreign-address {
            max-elements 4;
            description "Foreign address";
            leaf entry {
              type inet:ipv4-address;
              description "Foreign address";
            }
          }  // list foreign-address
    
          list packet-hold-queue {
            description
              "Sequence Number and datalength of each node in
             hold_pakqueue";
            uses TCP-NSR-HOLD-QUEUE-NODE;
          }  // list packet-hold-queue
    
          list internal-ack-hold-queue {
            description
              "Sequence Number and datalength of each node in
             hold_iackqueue";
            uses TCP-NSR-HOLD-QUEUE-NODE;
          }  // list internal-ack-hold-queue
        }  // grouping TCP-NSR-PCB-DETAILED-BAG
    
        grouping TCP-NSR-PCB-BRIEF-BAG {
          description
            "Summary NSR information about a TCP connection";
          leaf address-family {
            type Addr-family;
            description "Address family";
          }
    
          leaf pcb {
            type uint64;
            description "PCB Address";
          }
    
          leaf sscb {
            type uint64;
            description "SSCB Address";
          }
    
          leaf local-port {
            type uint16;
            description "Local port";
          }
    
          leaf foreign-port {
            type uint16;
            description "Foreign port";
          }
    
          leaf vrf-id {
            type uint32;
            description "VRF Id";
          }
    
          leaf is-admin-configured-up {
            type boolean;
            description
              "Is NSR administratively configured?";
          }
    
          leaf is-us-operational-up {
            type Nsr-status;
            description
              "Is Upstream NSR operational?";
          }
    
          leaf is-ds-operational-up {
            type Nsr-status;
            description
              "Is Downstream NSR operational?";
          }
    
          leaf is-only-receive-path-replication {
            type boolean;
            description
              "Is replication limited to receive-path only";
          }
    
          list local-address {
            max-elements 4;
            description "Local address";
            leaf entry {
              type inet:ipv4-address;
              description "Local address";
            }
          }  // list local-address
    
          list foreign-address {
            max-elements 4;
            description "Foreign address";
            leaf entry {
              type inet:ipv4-address;
              description "Foreign address";
            }
          }  // list foreign-address
        }  // grouping TCP-NSR-PCB-BRIEF-BAG
      }  // submodule Cisco-IOS-XR-ip-tcp-oper-sub1
    

© 2023 YumaWorks, Inc. All rights reserved.