module Cisco-IOS-XE-appqoe-tcpproxy-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-appqoe-tcpproxy-oper";

    prefix appqoe-tcpproxy-xe-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Application Quality of Experience (APPQOE) TCP proxy operational data.
     Copyright (c) 2020-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-07-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "1.0.0";

    typedef appqoe-proxy-state {
      type enumeration {
        enum "running" {
          value 0;
          description "TCP proxy is running";
        }
        enum "not-running" {
          value 1;
          description
            "TCP proxy is not running";
        }
      }
      description
        "APPQOE TCP proxy running state";
    }

    container appqoe-tcpproxy-oper-data {
      config false;
      description
        "APPQOE TCP proxy operational data";
      container appqoe-tcpproxy-status {
        presence "appqoe-tcpproxy-status";
        description
          "APPQOE TCP proxy configuration and status";
        leaf vpg-name {
          type string;
          description
            "Virtual Port Group(VPG) name";
        }

        leaf vpg-addr {
          type inet:ip-address;
          description "VPG IP address";
        }

        leaf vpg-netmask {
          type inet:ip-address;
          description "VPG IP mask";
        }

        leaf sng-name {
          type string;
          description
            "Service Node Group(SNG) name";
        }

        leaf sng-addr {
          type inet:ip-address;
          description "SNG IP address";
        }

        leaf oper-state {
          type appqoe-proxy-state;
          description
            "TCP proxy operational state";
        }
      }  // container appqoe-tcpproxy-status

      container appqoe-tcpproxy-stats {
        presence "appqoe-tcpproxy-stats";
        description
          "APPQOE TCP proxy statistics";
        leaf current-conn-count {
          type uint64;
          description "Current connections";
        }

        leaf conn-in-progress {
          type uint64;
          description
            "Connections in progress";
        }

        leaf cur-rx-epoll-count {
          type uint64;
          description
            "Current receive event library poll count";
        }

        leaf cur-tx-epoll-count {
          type uint64;
          description
            "Current transmitted event library poll count";
        }

        leaf total-conns {
          type uint64;
          description "Total connections";
        }

        leaf max-conns {
          type uint64;
          description
            "Maximum concurrent connections";
        }

        leaf conn-failed {
          type uint64;
          description "Failed connections";
        }

        leaf syncache-add-done {
          type uint64;
          description "SYN cache Added";
        }

        leaf sync-fail-nat-entry-null {
          type uint64;
          description
            "SYN cache not added due to NAT entry null";
        }

        leaf sync-fail-marked-cleanup {
          type uint64;
          description
            "SYN cache not added as it is marked for cleanup";
        }

        leaf sync-fail-entry-null {
          type uint64;
          description
            "SYN cache not added as flow entry is null";
        }

        leaf sync-fail-entry-invalid {
          type uint64;
          description
            "SYN cache not added as flow is invalid";
        }

        leaf sync-fail-entry-inuse {
          type uint64;
          description
            "SYN cache not added as flow is in use";
        }

        leaf syn-purged-enq {
          type uint64;
          description "SYN purge enqueued";
        }

        leaf syn-purge-enq-failed {
          type uint64;
          description
            "SYN purge enqueue failed";
        }

        leaf other-cleanup-enq {
          type uint64;
          description
            "Other cleanup enqueued";
        }

        leaf other-cleanup-enq-failed {
          type uint64;
          description
            "Other cleanup enqueue failed";
        }

        leaf proxy-cleanup-enq {
          type uint64;
          description
            "Proxy cleanup enqueued";
        }

        leaf proxy-cleanup-enq-failed {
          type uint64;
          description
            "Proxy cleanup enqueue failed";
        }

        leaf stack-cleanup-enq {
          type uint64;
          description
            "Stack cleanup enqueued";
        }

        leaf stack-cleanup-enq-failed {
          type uint64;
          description
            "Stack cleanup enqueue failed";
        }

        leaf timer-expire-cleanup-enq {
          type uint64;
          description
            "Timer expire cleanup enqueued";
        }

        leaf timer-ex-clean-enq-failed {
          type uint64;
          description
            "Timer expire cleanup enqueue failed";
        }

        leaf clean-req-watcher-called {
          type uint64;
          description
            "Cleanup request watcher called";
        }

        leaf pre-list-enq-failed {
          type uint64;
          description
            "Pre TCP flow list enqueue failed";
        }

        leaf pre-list-enq {
          type uint64;
          description
            "Pre TCP flow list enqueue success";
        }

        leaf pre-rem-err-accept {
          type uint64;
          description
            "Pre TCP flow list dequeue failed(accept)";
        }

        leaf pre-remove-err-timer {
          type uint64;
          description
            "Pre TCP flow list dequeue failed(timer)";
        }

        leaf pre-remove-cleanup {
          type uint64;
          description
            "Pre TCP flow list dequeue (cleanup)";
        }

        leaf pre-remove-accept {
          type uint64;
          description
            "Pre TCP flow list dequeue (accept)";
        }

        leaf pre-clean-time-update {
          type uint64;
          description
            "Pre TCP cleanup timeout update count";
        }

        list flow-pend-clean {
          description
            "Total flow entries pending cleanup";
          leaf index {
            type uint8;
            description "Instance ID";
          }

          leaf value {
            type uint64;
            description
              "Number of flows pending cleanup";
          }
        }  // list flow-pend-clean

        leaf tot-tcp-flow-clean-done {
          type uint64;
          description "Total cleanup done";
        }

        list worker-queue-info {
          description
            "SSL worker queue information";
          leaf index {
            type uint8;
            description "Instance ID";
          }

          leaf max-q-len-wk {
            type uint64;
            description
              "Maximum worker queue length";
          }

          leaf cur-q-len-wk {
            type uint64;
            description
              "Current worker queue length";
          }

          leaf max-q-len-ism {
            type uint64;
            description
              "Maximum Interposer Session Manager (ISM) queue length";
          }

          leaf cur-q-len-ism {
            type uint64;
            description
              "Current ISM queue length";
          }

          leaf max-q-len-sc {
            type uint64;
            description
              "Maximum Service Chain (SC) queue length";
          }

          leaf cur-q-len-sc {
            type uint64;
            description
              "Current SC queue length";
          }
        }  // list worker-queue-info

        leaf tot-pause-count {
          type uint64;
          description
            "Total paused by TCP due to transmit buffer full";
        }

        leaf tot-resume-count {
          type uint64;
          description
            "Total resumed by TCP transmit due to below threshold";
        }

        leaf tot-pause-count-buf {
          type uint64;
          description
            "Total paused by TCP due to buffer consumed";
        }

        leaf tot-resume-count-buf {
          type uint64;
          description
            "Total resumed by TCP due to buffer released";
        }

        leaf tot-rx-ssl-pause-process {
          type uint64;
          description
            "Total event by SSL to pause process";
        }

        leaf tot-rx-snort-pause-proc {
          type uint64;
          description
            "Total event by snort to pause process";
        }

        leaf tot-rx-dre-pause-process {
          type uint64;
          description
            "Total event by DRE to pause process";
        }

        leaf tot-ev-resume-process {
          type uint64;
          description
            "Total event by SSL/snort resume process";
        }

        leaf tot-ev-tx-enable-process {
          type uint64;
          description
            "Total transmit async events processed";
        }

        leaf tot-send-fail {
          type uint64;
          description
            "Total failure to send";
        }

        leaf tot-ssl-pause-done {
          type uint64;
          description "Total SSL pause done";
        }

        leaf tot-ssl-resume-done {
          type uint64;
          description
            "Total SSL resume done";
        }

        leaf tot-snort-pause-done {
          type uint64;
          description
            "Total snort pause done";
        }

        leaf tot-snort-resume-done {
          type uint64;
          description
            "Total snort resume done";
        }

        leaf tot-dre-pause-done {
          type uint64;
          description "Total DRE pause done";
        }

        leaf tot-dre-resume-done {
          type uint64;
          description
            "Total DRE resume done";
        }

        leaf tot-dre-resume-to-be-sent {
          type uint64;
          description
            "Total DRE resume to be sent";
        }

        leaf tot-dre-resume-msg-sent {
          type uint64;
          description
            "Total DRE resume message sent";
        }

        leaf tot-dre-close-init {
          type uint64;
          description
            "Total DRE close initiated";
        }

        leaf tot-actual-pause-done {
          type uint64;
          description
            "Total socket pause done";
        }

        leaf tot-actual-resume-done {
          type uint64;
          description
            "Total socket resume done";
        }

        leaf tot-ssl-pause-called {
          type uint64;
          description
            "Total SSL pause called";
        }

        leaf tot-ssl-resume-called {
          type uint64;
          description
            "Total SSL resume called";
        }

        leaf tot-async-event-send {
          type uint64;
          description
            "Total async events sent";
        }

        leaf tot-async-event-process {
          type uint64;
          description
            "Total async events processed";
        }

        leaf tot-tx-async-event-send {
          type uint64;
          description
            "Total transmit side async events sent";
        }

        leaf tot-tx-async-event-proc {
          type uint64;
          description
            "Total transmit side async events received";
        }

        leaf tot-tcp-fin-rcvd {
          type uint64;
          description
            "Total TCP FIN received from client/server";
        }

        leaf tot-tcp-reset-rcvd {
          type uint64;
          description
            "Total TCP RST received from client/server";
        }

        leaf tot-ssl-fin-rcvd {
          type uint64;
          description
            "Total TCP FIN received from SSL";
        }

        leaf tot-ssl-reset-rcvd {
          type uint64;
          description
            "Total TCP Reset received from SSL";
        }

        leaf tot-ssl-fin-rcvd-sc {
          type uint64;
          description
            "Total SC FIN received from SSL";
        }

        leaf tot-ssl-reset-rcvd-sc {
          type uint64;
          description
            "Total SC Reset received from SSL";
        }

        leaf tot-sc-fin-rcvd {
          type uint64;
          description
            "Total SSL FIN received from SC";
        }

        leaf tot-sc-reset-rcvd {
          type uint64;
          description
            "Total SSL reset received from SC";
        }

        leaf tot-fin-processed {
          type uint64;
          description
            "Total TCP FIN processed";
        }

        leaf tot-fin-ign-fd-close {
          type uint64;
          description
            "Total TCP FIN ignored as file descriptor already closed";
        }

        leaf tot-reset-processed {
          type uint64;
          description
            "Total TCP reset processed";
        }

        leaf tot-svc-reset-processed {
          type uint64;
          description
            "Total Service Chain (SVC) reset processed";
        }

        leaf tot-clean-client-data-q {
          type uint64;
          description
            "Total flow cleaned with client data";
        }

        leaf tot-clean-server-data-q {
          type uint64;
          description
            "Total flow cleaned with server data";
        }

        leaf tot-tcp-buf-alloc {
          type uint64;
          description
            "Total TCP 4k allocated buffers";
        }

        leaf tot-tcp-buf-16k-alloc {
          type uint64;
          description
            "Total TCP 16k allocated buffers";
        }

        leaf tot-tcp-buf-32k-alloc {
          type uint64;
          description
            "Total TCP 32k allocated buffers";
        }

        leaf tot-tcp-buf-128k-alloc {
          type uint64;
          description
            "Total TCP 128k allocated buffers";
        }

        leaf tot-tcp-buf-free {
          type uint64;
          description
            "Total TCP freed buffers";
        }

        leaf tot-ssl-buf-alloc {
          type uint64;
          description
            "Total SSL allocated buffers";
        }

        leaf tot-ssl-buf-free {
          type uint64;
          description
            "Total SSL freed buffers";
        }

        leaf tot-tcp-buf-rcvd {
          type uint64;
          description
            "Total TCP received buffers";
        }

        leaf tot-tcp2ssl-buf-enq {
          type uint64;
          description
            "Total TCP enqueued buffers to SSL";
        }

        leaf tot-ssl2svc-buf-enq {
          type uint64;
          description
            "Total SSL enqueued buffers SVC";
        }

        leaf tot-svc2ssl-buf-enq {
          type uint64;
          description
            "Total SVC enqueued buffers to SSL";
        }

        leaf tot-ssl2tcp-buf-enq {
          type uint64;
          description
            "Total SSL enqueued buffers to TCP";
        }

        leaf tot-tcp-buf-sent {
          type uint64;
          description
            "Total TCP buffers sent";
        }

        leaf tot-tcp-buf-alloc-failed {
          type uint64;
          description
            "Total TCP failed buffers allocations";
        }

        leaf tot-buf-16k-alloc-failed {
          type uint64;
          description
            "Total TCP failed 16k buffers allocations";
        }

        leaf tot-buf-32k-alloc-failed {
          type uint64;
          description
            "Total TCP failed 32k buffers allocations";
        }

        leaf tot-buf-128k-alloc-failed {
          type uint64;
          description
            "Total TCP failed 128k buffers allocations";
        }

        leaf tot-ssl-buf-alloc-failed {
          type uint64;
          description
            "Total SSL failed buffers allocations";
        }

        leaf tot-ssl-server-init {
          type uint64;
          description
            "Total SSL server init";
        }

        leaf flow-drop-sn-gbl-health-y {
          type uint64;
          description
            "Flows dropped by snort as global health is yellow";
        }

        leaf flow-drop-sn-inst-health-y {
          type uint64;
          description
            "Flows dropped as snort instance health is yellow";
        }

        leaf flows-drop-wcapi-health-y {
          type uint64;
          description
            "Flows dropped as communication channel health is yellow";
        }

        leaf tot-ssl-reset-init {
          type uint64;
          description
            "Total TCP reset initiated by SSL";
        }

        leaf tot-snort-reset-init {
          type uint64;
          description
            "Total TCP reset initiated by snort";
        }

        leaf tx-enqueue-drops-close {
          type uint64;
          description
            "Total transmit enqueue ignored due to connection close";
        }

        leaf ssl-init-failure {
          type uint64;
          description "SSL init failure";
        }

        leaf wcapi-svc-flow-create-f {
          type uint64;
          description
            "Total SVC chain flow create failed";
        }

        leaf wcapi-svc-flow-delete-f {
          type uint64;
          description
            "Total SVC chain flow delete failed";
        }

        leaf wcapi-svc-data-send-f {
          type uint64;
          description
            "Total SVC chain send data failed";
        }

        leaf wcapi-svc-flow-close-f {
          type uint64;
          description
            "Total SVC chain send close failed";
        }

        leaf tx-enq-failure-count {
          type uint64;
          description
            "Total transmit enqueue failed";
        }

        leaf tot-bytes-read-less-512 {
          type uint64;
          description
            "Total received socket bytes less than 512 ";
        }

        leaf tot-bytes-read-less-1024 {
          type uint64;
          description
            "Total received socket bytes less than 1024";
        }

        leaf tot-bytes-read-less-2048 {
          type uint64;
          description
            "Total received socket bytes less than 2048";
        }

        leaf tot-bytes-read-less-4096 {
          type uint64;
          description
            "Total received socket bytes less than 4096";
        }

        leaf tot-buff-drop-sock-not-av {
          type uint64;
          description
            "Total buffers dropped in transmit direction due to socket not available";
        }

        leaf tot-buff-drop-sock-closed {
          type uint64;
          description
            "Total buffers dropped in transmit direction due to socket close";
        }

        leaf tot-uhi-mmap {
          type uint64;
          description
            "Total Universal Memory Allocator(UMA) memory map";
        }

        leaf tot-uhi-munmap {
          type uint64;
          description
            "Total UMA memory unmap";
        }

        leaf enable-rx-called {
          type uint64;
          description
            "Total receive enable called";
        }

        leaf enable-rx-done {
          type uint64;
          description
            "Total receive enable process done";
        }

        leaf enable-rx-queued {
          type uint64;
          description
            "Total receive enable enqueued";
        }

        leaf enable-rx-failed {
          type uint64;
          description
            "Total receive enable process failed";
        }

        leaf enable-rx-enq-failed {
          type uint64;
          description
            "Total receive enable enqueue failed";
        }

        leaf tot-cleanup-add-to-wk-q {
          type uint64;
          description
            "Total cleanup flow message added to worker queue";
        }

        leaf tot-clean-add-wk-q-fail {
          type uint64;
          description
            "Total cleanup flow add message to worker queue failed";
        }

        leaf tot-clean-msg-rcvd {
          type uint64;
          description
            "Total cleanup flow message received in worker queue";
        }

        leaf tot-clean-flow-ign {
          type uint64;
          description
            "Total cleanup flow ignored as it is already done";
        }

        leaf tot-ssl-clean-addwkq-fail {
          type uint64;
          description
            "Total cleanup SSL message add to worker queue failed";
        }

        leaf tot-ssl-trig-rst-wkq-fail {
          type uint64;
          description
            "Total SSL trigger reset message add to worker queue failed";
        }

        leaf num-stack-cb-null-ctx {
          type uint64;
          description
            "Number of stack callback with null context";
        }

        leaf vpath-cleanup-from-nmrx {
          type uint64;
          description
            "Virtual path cleanup from receive thread";
        }

        leaf vpath-cleanup-from-evlib {
          type uint64;
          description
            "Virtual path cleanup from event thread";
        }

        leaf curr-tcp-flow-entries {
          type uint64;
          description "Current flow entries";
        }

        leaf curr-val-tcp-flow-entries {
          type uint64;
          description
            "Current valid flow entries";
        }

        leaf tcp-flow-entries-created {
          type uint64;
          description "Flow entries created";
        }

        leaf tcp-flow-entries-deleted {
          type uint64;
          description "Flow entries deleted";
        }

        leaf tcp-flow-stats-del-fail {
          type uint64;
          description
            "Flow delete failure count";
        }

        leaf tcp-flow-stats-add-fail {
          type uint64;
          description
            "Flow add failure count";
        }

        leaf tcp-flow-inv-entries {
          type uint64;
          description "Invalid flow entries";
        }

        leaf tot-en-rx-sock-stk-cl-clnt {
          type uint64;
          description
            "Total receive socket enable due to client side stack close";
        }

        leaf tot-en-rx-sock-stk-cl-svr {
          type uint64;
          description
            "Total receive socket enable due to server side stack close";
        }

        leaf unified-logging-msg-recvd {
          type uint64;
          description
            "Unified logging message received";
        }

        leaf unified-logg-data-too-long {
          type uint64;
          description
            "Unified logging drop as data is too long";
        }

        leaf unified-logg-enq-succ {
          type uint64;
          description
            "Unified logging enqueue success";
        }

        leaf unified-logg-deq-succ {
          type uint64;
          description
            "Unified logging dequeue success";
        }

        leaf unif-logg-deq-no-space {
          type uint64;
          description
            "Unified logging dequeue failed as there is not enough space";
        }

        leaf tot-page-alloc {
          type uint64;
          description
            "Total UMA page allocations";
        }

        leaf tot-page-alloc-retry {
          type uint64;
          description
            "Total UMA page allocation retry";
        }

        leaf tot-page-alloc-failed {
          type uint64;
          description
            "Total UMA page allocation failed";
        }

        leaf tot-page-alloc-fail-size {
          type uint64;
          description
            "Total UMA page allocation failed due to invalid size";
        }

        leaf tot-page-free {
          type uint64;
          description "Total UMA page free";
        }

        leaf tcpp-aoim-sync-started {
          type uint64;
          description
            "Application optimiser information manager sync started";
        }

        leaf tcpp-aoim-sync-done {
          type uint64;
          description
            "Application optimiser information manager sync completed";
        }

        leaf tcpp-aoim-sync-error {
          type uint64;
          description
            "Application optimiser information manager sync errored";
        }

        leaf sync-flow-mismatch {
          type uint64;
          description
            "Syn cache flow mismatch";
        }

        leaf proxy-cleanup-to-queue {
          type uint64;
          description
            "Proxy cleanup sent to event loop flow queue";
        }

        leaf proxy-cleanup-by-queue {
          type uint64;
          description
            "Proxy cleanup enqueue done by event loop flow queue";
        }
      }  // container appqoe-tcpproxy-stats
    }  // container appqoe-tcpproxy-oper-data
  }  // module Cisco-IOS-XE-appqoe-tcpproxy-oper