junos-rpc-shmlog

Junos RPC YANG module for shmlog command(s)

  • Version: 2019-01-01

    junos-rpc-shmlog@2019-01-01


    
      module junos-rpc-shmlog {
    
        yang-version 1;
    
        namespace
          "http://yang.juniper.net/junos/rpc/shmlog";
    
        prefix shmlog;
    
        import junos-common-types {
          prefix jt;
          revision-date "2019-01-01";
        }
    
        organization "Juniper Networks, Inc.";
    
        contact "yang-support@juniper.net";
    
        description
          "Junos RPC YANG module for shmlog command(s)";
    
        revision "2019-01-01" {
          description "Junos: 21.3R1.9";
        }
    
    
        rpc get-shmlog-argument-mappings {
          description
            "Show argument mapping information";
          input {
            leaf argument-name {
              type string;
              mandatory true;
              description
                "Name of shmlog argument";
            }
    
            leaf memory-filename {
              type string;
              description
                "Filename that holds copy of memory to use for display";
            }
    
            leaf files-path {
              type string;
              description
                "Root path to use to find files with info";
            }
          }
    
          output {
            choice output_c {
              leaf output {
                type string;
              }
              anyxml shmlog;
              anyxml multi-routing-engine-results;
            }  // choice output_c
          }
        }  // rpc get-shmlog-argument-mappings
    
        rpc get-shmlog-entries {
          description
            "Show log entry information";
          input {
            leaf logname {
              type string;
              mandatory true;
              description
                "Log name(s). Comma delimited list and wildcarding supported";
            }
    
            leaf memory-filename {
              type string;
              description
                "Filename that holds copy of memory to use for display";
            }
    
            leaf filename {
              type string;
              description
                "Filename to trace the logs";
            }
    
            leaf files-path {
              type string;
              description
                "Root path to use to find files with info";
            }
    
            container filters {
              leaf name {
                type string;
                description
                  "Filter to be applied";
              }
    
              leaf value {
                type string;
                description "Variable value";
              }
            }  // container filters
    
            leaf context-switch {
              type enumeration {
                enum "context-switches" {
                  value 0;
                  description
                    "Show context switch information";
                }
              }
            }
    
            leaf cpu-usage {
              type enumeration {
                enum "cpu-usage" {
                  value 0;
                  description
                    "Show cpu usage information";
                }
              }
            }
    
            leaf date-time {
              type enumeration {
                enum "date-time" {
                  value 0;
                  description
                    "Show time in date/time format (Mon DD HH:MM:SS.uuuuuu)";
                }
              }
            }
    
            leaf short-time {
              type enumeration {
                enum "short-time" {
                  value 0;
                  description
                    "Show time in short date/time format (Mon DD HH:MM:SS)";
                }
              }
            }
    
            leaf flag-name {
              type enumeration {
                enum "accounting-statistics" {
                  value 0;
                  description
                    "Display ppp accounting statistics events";
                }
                enum "authentication" {
                  value 1;
                  description
                    "Display authentication code events";
                }
                enum "chap" {
                  value 2;
                  description
                    "Display ppp chap code events";
                }
                enum "events" {
                  value 3;
                  description
                    "Display interface events";
                }
                enum "gres" {
                  value 4;
                  description
                    "Display gres events";
                }
                enum "init" {
                  value 5;
                  description
                    "Display daemon initialization events";
                }
                enum "interface-db" {
                  value 6;
                  description
                    "Display ppp interface database code events";
                }
                enum "lcp" {
                  value 7;
                  description
                    "Display ppp lcp state machine code events";
                }
                enum "memory" {
                  value 8;
                  description
                    "Display memory management code events";
                }
                enum "ncp" {
                  value 9;
                  description
                    "Display ppp ncp state machine code events";
                }
                enum "packet-error" {
                  value 10;
                  description
                    "Display Packet events";
                }
                enum "pap" {
                  value 11;
                  description
                    "Display ppp pap code events";
                }
                enum "parse" {
                  value 12;
                  description
                    "Display parsing events ";
                }
                enum "profile" {
                  value 13;
                  description
                    "Display libdynamic-profile events";
                }
                enum "packets" {
                  value 14;
                  description
                    "Display packet events";
                }
                enum "routing-process" {
                  value 15;
                  description
                    "Display routing process interactions events";
                }
                enum "rtp" {
                  value 16;
                  description
                    "Display ppp Real Time Priority code events";
                }
                enum "rtsock" {
                  value 17;
                  description
                    "Display routing socket code";
                }
                enum "session-db" {
                  value 18;
                  description
                    "Display session database interactions code";
                }
                enum "smi-services-sentry" {
                  value 19;
                  description
                    "Display ppp smi-services-sentry code";
                }
                enum "states" {
                  value 20;
                  description
                    "Display state machine events";
                }
                enum "tunnel" {
                  value 21;
                  description
                    "Display l2tp tunneling events";
                }
                enum "database" {
                  value 22;
                  description
                    "Display dhcp Database operations";
                }
                enum "flow" {
                  value 23;
                  description
                    "Display dhcp Flow related operations";
                }
                enum "fwd" {
                  value 24;
                  description
                    "Display dhcp Firewall process operations";
                }
                enum "ha" {
                  value 25;
                  description
                    "Display dhcp High Availability related operations";
                }
                enum "liveness-detection" {
                  value 26;
                  description
                    "Display dhcp Liveness detection operations";
                }
                enum "persistent" {
                  value 27;
                  description
                    "Display dhcp Persistent file operations";
                }
                enum "general" {
                  value 28;
                  description
                    "Display dhcp General operations";
                }
                enum "message" {
                  value 29;
                  description
                    "Display l2tp message operations";
                }
                enum "protocol" {
                  value 30;
                  description
                    "Display l2tp protocol operations";
                }
                enum "ipc-tx" {
                  value 31;
                  description
                    "Display l2tp IPC transmit operations";
                }
                enum "ipc-rx" {
                  value 32;
                  description
                    "Display l2tp IPC receive operations";
                }
                enum "timer" {
                  value 33;
                  description
                    "Display l2tp timer operations";
                }
                enum "error" {
                  value 34;
                  description
                    "Display l2tp error operations";
                }
                enum "user-access" {
                  value 35;
                  description
                    "Display authd Subscriber events";
                }
                enum "gx-plus" {
                  value 36;
                  description
                    "Display authd gx-plus events";
                }
                enum "jsrc" {
                  value 37;
                  description
                    "Display authd jsrc events";
                }
                enum "authd-framework" {
                  value 38;
                  description
                    "Display authd authentication framework events";
                }
                enum "radius" {
                  value 39;
                  description
                    "Display authd radius authentication events";
                }
                enum "addr-assign" {
                  value 40;
                  description
                    "Display authd address-assignment events";
                }
                enum "local-auth" {
                  value 41;
                  description
                    "Display authd local authentication events";
                }
                enum "lib-stats" {
                  value 42;
                  description
                    "Display authd lib stats events";
                }
                enum "ldap" {
                  value 43;
                  description
                    "Display authd  ldap authentication eventss";
                }
                enum "securid" {
                  value 44;
                  description
                    "Display authd securid events";
                }
              }
              description
                "Display logs pertaining to applied flag events";
            }
    
            leaf delta-time {
              type enumeration {
                enum "delta-time" {
                  value 0;
                  description "Show delta time";
                }
              }
            }
    
            leaf display-time-order {
              type enumeration {
                enum "older-first" {
                  value 0;
                  description
                    "Show entries from oldest to newest";
                }
                enum "newer-first" {
                  value 1;
                  description
                    "Show entries from newest to oldest";
                }
              }
              default "older-first";
            }
    
            leaf earliest-maximum {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Maximum entries to show starting with earliest";
            }
    
            leaf end-from-latest-days {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries ending with specified duration from latest";
            }
    
            leaf end-from-latest-hours {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries ending with specified duration from latest";
            }
    
            leaf end-from-latest-minutes {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries ending with specified duration from latest";
            }
    
            leaf end-from-latest-seconds {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
            }
    
            leaf epoch-time {
              type enumeration {
                enum "epoch-time" {
                  value 0;
                  description
                    "Show time from 1970 epoch in decimal format (ssssssssss.uuuuuu)";
                }
              }
            }
    
            leaf event-id-options {
              type string;
              description
                "Event ids options to show mask (hex value 0x[A-Fa-f0-9])";
            }
    
            leaf latest-maximum {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Maximum entries to show starting with latest";
            }
    
            leaf min-log-type {
              type string;
              description
                "Minimum log type to display from (number or user definition)";
            }
    
            leaf max-log-type {
              type string;
              description
                "Maximum log type to display from (number or user definition)";
            }
    
            leaf no-time-display {
              type enumeration {
                enum "no-time-display" {
                  value 0;
                  description "Don't show time";
                }
              }
            }
    
            leaf pid {
              type enumeration {
                enum "pid-info" {
                  value 0;
                  description
                    "Show pid information";
                }
              }
            }
    
            leaf remember {
              type enumeration {
                enum "remember" {
                  value 0;
                  description
                    "Remember these display options";
                }
                enum "no-remember" {
                  value 1;
                  description
                    "No remember these display options";
                }
              }
            }
    
            leaf repeat-count {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000";
                }
              }
              description
                "Number of times to show the log";
            }
    
            leaf repeat-interval {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000";
                }
              }
              description
                "Interval in seconds between each showing";
            }
    
            leaf start-from-latest-days {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries starting with specified duration from latest";
            }
    
            leaf start-from-latest-hours {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries starting with specified duration from latest";
            }
    
            leaf start-from-latest-minutes {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries starting with specified duration from latest";
            }
    
            leaf start-from-latest-seconds {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type int32 {
                  range "1 .. 1000000000";
                }
              }
              description
                "Show entries starting with specified duration from latest";
            }
    
            leaf thread {
              type enumeration {
                enum "thread-info" {
                  value 0;
                  description
                    "Show thread information";
                }
              }
            }
    
            leaf verbose-time {
              type enumeration {
                enum "verbose-time" {
                  value 0;
                  description
                    "Show verbose time";
                }
              }
            }
    
            leaf no-entry-num {
              type enumeration {
                enum "no-entry-num" {
                  value 0;
                  description
                    "Do not show the entry number";
                }
              }
            }
    
            leaf pack-event {
              type enumeration {
                enum "pack-event" {
                  value 0;
                  description
                    "Pack event string immediately after its ID";
                }
              }
            }
          }
    
          output {
            choice output_c {
              leaf output {
                type string;
              }
              anyxml shmlog;
              anyxml multi-routing-engine-results;
            }  // choice output_c
          }
        }  // rpc get-shmlog-entries
    
        rpc get-shmlog-configuration {
          description "Show log configuration";
          input {
            leaf logname {
              type string;
              mandatory true;
              description
                "Log name(s). Comma delimited list and wildcarding supported";
            }
    
            leaf memory-filename {
              type string;
              description
                "Filename that holds copy of memory to use for display";
            }
    
            leaf files-path {
              type string;
              description
                "Root path to use to find files with info";
            }
          }
    
          output {
            choice output_c {
              leaf output {
                type string;
              }
              anyxml shmlog;
              anyxml multi-routing-engine-results;
            }  // choice output_c
          }
        }  // rpc get-shmlog-configuration
    
        rpc get-shmlog-statistics {
          description "Show log statistics";
          input {
            leaf logname {
              type string;
              mandatory true;
              description
                "Log name(s). Comma delimited list and wildcarding supported";
            }
    
            leaf memory-filename {
              type string;
              description
                "Filename that holds copy of memory to use for display";
            }
    
            leaf files-path {
              type string;
              description
                "Root path to use to find files with info";
            }
          }
    
          output {
            choice output_c {
              leaf output {
                type string;
              }
              anyxml shmlog;
              anyxml multi-routing-engine-results;
            }  // choice output_c
          }
        }  // rpc get-shmlog-statistics
    
        rpc get-shmlog-logsummary {
          description "Show summary of all logs";
          input {
            leaf memory-filename {
              type string;
              description
                "Filename that holds copy of memory to use for display";
            }
    
            leaf files-path {
              type string;
              description
                "Root path to use to find files with info";
            }
          }
    
          output {
            choice output_c {
              leaf output {
                type string;
              }
              anyxml shmlog;
              anyxml multi-routing-engine-results;
            }  // choice output_c
          }
        }  // rpc get-shmlog-logsummary
    
        grouping command-forwarding {
          choice chassis-selector {
            leaf all-chassis {
              type empty;
              description "All chassis";
            }
            leaf all-lcc {
              type empty;
              description "All LCC chassis";
            }
            leaf scc {
              type empty;
              description "SCC";
            }
            leaf sfc {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type uint32;
              }
              description "SFC";
            }
            leaf lcc {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type uint32;
              }
              description "Specific LCC";
            }
            leaf node {
              type string;
              description "Specific node";
            }
            leaf bsys {
              type empty;
              description "Base system";
            }
            leaf gnf {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type uint32 {
                  range "1 .. 10";
                }
              }
              description
                "Specific guest network function";
            }
            leaf all-gnfs {
              type empty;
              description
                "All guest network functions";
            }
            leaf all-system {
              type empty;
              description
                "All system (BSYS and GNFs)";
            }
            leaf server {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type uint32 {
                  range "0 .. 1";
                }
              }
              description "Specific server slot";
            }
            leaf all-servers {
              type empty;
              description "All servers";
            }
            leaf vnf {
              type string;
              description
                "Specific virtual-network-function";
            }
            leaf all-vnfs {
              type empty;
              description
                "All virtual-network-functions";
            }
          }  // choice chassis-selector
    
          choice re-selector {
            leaf re0 {
              type empty;
              description "RE0";
            }
            leaf re1 {
              type empty;
              description "RE1";
            }
            leaf routing-engine {
              type enumeration {
                enum "local" {
                  value 0;
                  description
                    "Local routing engine";
                }
                enum "other" {
                  value 1;
                  description
                    "Other routing engine";
                }
                enum "master" {
                  value 2;
                  description
                    "Master routing engine";
                }
                enum "backup" {
                  value 3;
                  description
                    "Backup routing engine";
                }
                enum "both" {
                  value 4;
                  description
                    "Both routing engines";
                }
              }
              description
                "Specific routing engine";
            }
          }  // choice re-selector
    
          choice lr-selector {
            leaf logical-system {
              type string;
              description
                "Name of logical system, or 'all'";
            }
          }  // choice lr-selector
    
          choice tenant-selector {
            leaf tenant {
              type string;
              description
                "Name of tenant, or 'all'";
            }
          }  // choice tenant-selector
    
          choice vc-selector {
            leaf local {
              type empty;
              description
                "Local virtual chassis member";
            }
            leaf all-members {
              type empty;
              description
                "All virtual chassis members";
            }
            leaf member {
              type union {
                type string {
                  pattern "<.*>|$.*";
                }
                type uint32;
              }
              description
                "Specific virtual chassis member";
            }
          }  // choice vc-selector
        }  // grouping command-forwarding
      }  // module junos-rpc-shmlog
    

© 2023 YumaWorks, Inc. All rights reserved.