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

    grouping appqoe-tcpproxy-status {
      description
        "TCP proxy configuration and status details";
      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";
      }
    }  // grouping appqoe-tcpproxy-status

    grouping pend-clean {
      description
        "TCP proxy number of flows pending cleanup";
      leaf index {
        type uint8;
        description "Instance ID";
      }

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

    grouping 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";
      }
    }  // grouping queue-info

    grouping 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";
        uses appqoe-tcpproxy-xe-oper:pend-clean;
      }  // 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";
        uses appqoe-tcpproxy-xe-oper:queue-info;
      }  // 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";
      }
    }  // grouping appqoe-tcpproxy-stats

    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";
        uses appqoe-tcpproxy-xe-oper:appqoe-tcpproxy-status;
      }  // container appqoe-tcpproxy-status

      container appqoe-tcpproxy-stats {
        presence "appqoe-tcpproxy-stats";
        description
          "APPQOE TCP proxy statistics";
        uses appqoe-tcpproxy-xe-oper:appqoe-tcpproxy-stats;
      }  // container appqoe-tcpproxy-stats
    }  // container appqoe-tcpproxy-oper-data
  }  // module Cisco-IOS-XE-appqoe-tcpproxy-oper