module Cisco-IOS-XR-sysadmin-pm {

    yang-version 1;

    namespace
      "http://www.cisco.com/ns/yang/Cisco-IOS-XR-sysadmin-pm";

    prefix pmh;

    import tailf-common {
      prefix tailf;
    }
    import tailf-xsd-types {
      prefix xs;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-sysadmin-show-trace {
      prefix show_trace;
    }
    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 module contains a collection of YANG
     definitions for Cisco IOS-XR SysAdmin configuration.
     
     The Process Manager (PM).
     
     Copyright (c) 2011-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-06-13" {
      description
        "Fixed canonical order errors";
    }

    revision "2019-04-15" {
      description
        "Establish semantic version baseline.";
    }

    revision "2018-04-09" {
      description
        "Required changes for ConfD 6.4.5";
    }

    revision "2017-04-12" {
      description
        "Changed the namespace and module name";
    }

    revision "2016-05-11" {
      description "Initial version.";
    }

    semver:module-version "1.0.0";

    typedef startupMode {
      type enumeration {
        enum "ON-BOOTUP" {
          value 0;
        }
        enum "ON-SELECTION" {
          value 1;
        }
        enum "ON-DEMAND" {
          value 2;
        }
      }
    }

    typedef processState {
      type enumeration {
        enum "IDLE" {
          value 0;
        }
        enum "RUNNING" {
          value 1;
        }
        enum "STOPPING" {
          value 2;
        }
        enum "STOPPED" {
          value 3;
        }
        enum "DESELECTING" {
          value 4;
        }
        enum "DESELECTED" {
          value 5;
        }
      }
    }

    typedef serviceScope {
      type enumeration {
        enum "SYSTEM" {
          value 0;
        }
        enum "RACK" {
          value 1;
        }
      }
    }

    typedef serviceState {
      type enumeration {
        enum "SS_IDLE" {
          value 0;
        }
        enum "SS_RUNNING" {
          value 1;
        }
        enum "SS_ACK_PENDING" {
          value 2;
        }
      }
    }

    typedef serviceRole {
      type enumeration {
        enum "NONE" {
          value 0;
        }
        enum "ACTIVE" {
          value 1;
        }
        enum "STANDBY" {
          value 2;
        }
      }
    }

    typedef proc-name-type {
      type string;
    }

    typedef user-name-type {
      type string;
    }

    typedef task-name-type {
      type string;
    }

    typedef folder-name-type {
      type string;
    }

    typedef source-name-type {
      type string;
    }

    typedef dest-name-type {
      type string;
    }

    typedef file-name-type {
      type string;
    }

    typedef folder-file-name-type {
      type string;
    }

    typedef instance-id-type {
      type uint32;
    }

    typedef service-name-type {
      type string;
    }

    typedef proc-id-type {
      type uint32;
    }

    typedef node-name-type {
      type string;
    }

    container processes {
      config false;
      description "Process Info";
      list all-locations {
        key "location";
        leaf location {
          type string;
        }

        leaf ip-addr {
          type inet:ip-address;
          description
            "IP address of the location";
        }

        leaf pcbs {
          type uint32;
          description
            "Total number of process control blocks";
        }

        list name {
          tailf:action "proc-action" {
            input {
              leaf "do-what" {
                type "enumeration" {
                  enum "crash";
                  enum "restart";
                  enum "disable-heartbeat";
                  enum "enable-heartbeat";
                  enum "start";
                  enum "shutdown";
                  enum "mandatory-toggle";
                }
                mandatory "true";
              }
              leaf "user-name" {
                type "string";
                mandatory "true";
                description "Name of the logged in user";
              }
              leaf "user-ip" {
                type "string";
                mandatory "true";
                description "IP address of the user";
              }
            }
            output {
              leaf "proc-action-status" {
                type "string";
                mandatory "true";
              }
            }
          }
          key "proc-name instance-id";
          leaf proc-name {
            type proc-name-type;
            description
              "Name of the process";
          }

          leaf instance-id {
            type instance-id-type;
            description
              "Instance identifier";
          }

          leaf path {
            type string;
            description "Process path";
          }

          leaf startup-file {
            type string;
            description
              "Process startup file";
          }

          leaf startup-mode {
            type startupMode;
            description
              "When is a process started";
          }

          leaf heart-beat-timeout {
            type uint32;
            description
              "Heart beat timeout in sec";
          }

          leaf last-heart-beat-time {
            type xs:double;
            description
              "How long ago last heart beat was detected";
          }

          leaf max-restarts {
            type uint32;
            description
              "Maximum num of restarts";
          }

          leaf respawn-reset-timer {
            type uint32;
            description
              "Respawn reset timer in min";
          }

          leaf mandatory {
            type boolean;
            description "Mandatory process";
          }

          leaf maint-mode {
            type boolean;
            description
              "Should run during maintenance mode";
          }

          leaf args {
            type string;
            description "Process arguments";
          }

          leaf proc-state {
            type processState;
            description
              "State of the process";
          }

          leaf pid {
            type int32;
            description "Process ID";
          }

          leaf proc-aborted {
            type boolean;
            description
              "Whether the processes ever aborted";
          }

          leaf exit-status {
            type string;
            description
              "Last exit status/info of the process";
          }

          leaf respawns {
            type int32;
            description
              "Total number of respawns of the process";
          }

          leaf start-time {
            type string;
            description
              "Last start date and time";
          }

          leaf ready-time {
            type xs:double;
            description
              "Time for ready from start-time";
          }

          leaf last-exit-time {
            type string;
            description
              "Last exit date and time";
          }

          list services {
            key "service-name";
            leaf service-name {
              type string;
              description
                "Name of the service";
            }

            leaf scope {
              type serviceScope;
              description
                "Scope of the service";
            }

            leaf redundancy {
              type boolean;
              description
                "Service redundancy support";
            }

            leaf ha-ready {
              type boolean;
              description
                "Standby ready for HA";
            }

            leaf service-state {
              type serviceState;
              description
                "State of the service";
            }

            leaf ha-role {
              type serviceRole;
              description "Service role";
            }

            leaf new-ha-role {
              type serviceRole;
              description
                "New service role, different if PM in process of assigning";
            }

            leaf selected {
              type boolean;
              description
                "Service seleted to run on the node";
            }

            leaf ip1 {
              type inet:ip-address;
              description
                "First IP address in the selection";
            }

            leaf ip2 {
              type inet:ip-address;
              description
                "Second IP address in the selection";
            }

            leaf svc-start-time {
              type string;
              description
                "Last start date and time";
            }

            leaf svc-ready-time {
              type xs:double;
              description
                "Time it took to get ready since start time";
            }

            leaf svc-haready-time {
              type xs:double;
              description
                "Time it took to get HA-ready since start time";
            }
          }  // list services
        }  // list name
      }  // list all-locations
    }  // container processes

    container process-manager {
      config false;
      description "Process Manager Info";
      list all-locations-info {
        key "location-info";
        leaf location-info {
          type string;
        }

        leaf ip-addr-info {
          type inet:ip-address;
          description
            "IP address of the location";
        }

        leaf pm-start-time {
          type string;
          description
            "Last start date and time for PM";
        }

        leaf mand-proc-down {
          type boolean;
          description
            "PM in mandatory process down state";
        }

        leaf vmm-capi-up {
          type boolean;
          description
            "Status of CAPI with vm-manager";
        }

        leaf wdmon-capi-up {
          type boolean;
          description
            "Status of CAPI with wdmon";
        }

        leaf wdmon-capi-timestamp {
          type string;
          description
            "Date and time of last wdmon CAPI connection establish";
        }

        leaf wdmon-num-capi-connects {
          type uint32;
          description
            "Number of times wdmon CAPI connection extablished";
        }
      }  // list all-locations-info
    }  // container process-manager

    container pm {
      config false;
      container pm {
        list trace {
          key "buffer";
          config false;
          description
            "show traceable processes";
          leaf buffer {
            type string;
          }

          list location {
            key "location_name";
            leaf location_name {
              type string;
            }

            list all-options {
              key "option";
              leaf option {
                type string;
              }

              list trace-blocks {
                leaf data {
                  type string;
                  description
                    "Trace output block";
                }
              }  // list trace-blocks
            }  // list all-options
          }  // list location
        }  // list trace
      }  // container pm
    }  // container pm
  }  // module Cisco-IOS-XR-sysadmin-pm