module ietf-netconf-monitoring {

      yang-version 1;

      namespace
         "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring";

      prefix "ncm";

      import ietf-yang-types {
         prefix "yang";
      }
      import ietf-inet-types {
         prefix "inet";
      }

      organization
         "IETF NETCONF (Network Configuration) Working Group";

      contact
         "WG Web:   <http://tools.ietf.org/wg/netconf/>
         WG List:  <mailto:netconf@ietf.org>
         
         WG Chair: Mehmet Ersue
         	  <mailto:mehmet.ersue@nsn.com>
         
         WG Chair: Bert Wijnen
         	  <mailto:bertietf@bwijnen.net>
         
         Editor:   Mark Scott
         	  <mailto:mark.scott@ericsson.com>
         
         Editor:   Martin Bjorklund
         	  <mailto:mbj@tail-f.com>";

      description
         "NETCONF Monitoring Module.
         All elements in this module are read-only.
         
         Copyright (c) 2010 IETF Trust and the persons identified as
         the document authors.  All rights reserved.
         
         Redistribution and use in source and binary forms, with or
         without modification, is permitted pursuant to, and subject
         to the license terms contained in, the Simplified BSD License
         set forth in Section 4.c of the IETF Trust's Legal Provisions
         Relating to IETF Documents
         (http://trustee.ietf.org/license-info).
         
         This version of this YANG module is part of RFC XXXX; see
         the RFC itself for full legal notices.";

      revision "2010-06-01" {
         description "Initial revision.";
         reference
            "RFC XXXX: YANG Module for NETCONF Monitoring";

      }


      typedef netconf-datastore-type {
         type enumeration {
            enum "running" {
               value 0;
            }
            enum "candidate" {
               value 1;
            }
            enum "startup" {
               value 2;
            }
         }
         description
            "Enumeration of possible NETCONF datastore types.";
         reference
            "RFC 4741: NETCONF Configuration Protocol";

      }

      identity transport {
         description
            "Base identity for NETCONF transport types.";
      }

      identity netconf-ssh {
         base transport;
         description "NETCONF over Secure Shell (SSH).";
         reference
            "RFC 4742: Using the NETCONF Configuration Protocol
            	  over Secure SHell (SSH)";

      }

      identity netconf-soap-over-beep {
         base transport;
         description
            "NETCONF over Simple Object Access Protocol (SOAP) over
            Blocks Extensible Exchange Protocol (BEEP).";
         reference
            "RFC 4743: Using NETCONF over the Simple Object
            	  Access Protocol (SOAP)";

      }

      identity netconf-soap-over-https {
         base transport;
         description
            "NETCONF over Simple Object Access Protocol (SOAP)
            over Hypertext Transfer Protocol Secure (HTTPS).";
         reference
            "RFC 4743: Using NETCONF over the Simple Object
            	  Access Protocol (SOAP)";

      }

      identity netconf-beep {
         base transport;
         description
            "NETCONF over Blocks Extensible Exchange Protocol (BEEP).";
         reference
            "RFC 4744: Using the NETCONF Protocol over the
            	  Blocks Extensible Exchange Protocol (BEEP)";

      }

      identity netconf-tls {
         base transport;
         description
            "NETCONF over Transport Layer Security (TLS).";
         reference
            "RFC 5539: NETCONF over Transport Layer Security (TLS)";

      }

      identity schema-format {
         description
            "Base identity for data model schema languages.";
      }

      identity xsd {
         base schema-format;
         description "W3C XML Schema Definition.";
         reference
            "W3C REC REC-xmlschema-1-20041028: XML Schema Part 1: Structure
            W3C REC REC-xmlschema-2-20041028: XML Schema Part 2: Datatypes";

      }

      identity yang {
         base schema-format;
         description
            "The YANG data modeling language for NETCONF.";
         reference
            "RFC XXXX:  YANG - A data modeling language for NETCONF";

      }

      identity yin {
         base schema-format;
         description "The YIN syntax for YANG.";
         reference
            "RFC XXXX:  YANG - A data modeling language for NETCONF";

      }

      identity rng {
         base schema-format;
         description
            "Regular Language for XML Next Generation (RELAX NG).";
         reference
            "ISO/IEC 19757-2: RELAX NG";

      }

      identity rnc {
         base schema-format;
         description "Relax NG Compact Syntax";
         reference
            "ISO/IEC 19757-2: RELAX NG";

      }

      grouping common-counters {
         description
            "Counters that exist both per session, and also globally,
            accumulated from all sessions.";
         leaf in-rpcs {
            type yang:zero-based-counter32;
            description
               "Number of correct <rpc> messages received.";
         }

         leaf in-bad-rpcs {
            type yang:zero-based-counter32;
            description
               "Number of messages received when a <rpc> message was expected,
               that were not correct <rpc> messages.  This includes XML parse
               errors and errors on the rpc layer.";
         }

         leaf out-rpc-errors {
            type yang:zero-based-counter32;
            description
               "Number of <rpc-reply> messages sent which contained an
               <rpc-error> element.";
         }

         leaf out-notifications {
            type yang:zero-based-counter32;
            description
               "Number of <notification> messages sent.";
         }
      }  // grouping common-counters

      container netconf-state {
         config "false";
         description
            "The netconf-state container is the root of the monitoring
            data model.";
         container capabilities {
            description
               "Contains the list of NETCONF capabilities supported by the
               server.";
            leaf-list capability {
               type inet:uri;
               description
                  "List of NETCONF capabilities supported by the server.";
            }
         }  // container capabilities

         container datastores {
            description
               "Contains the list of NETCONF configuration datastores.";
            list datastore {
               key "name";
               description
                  "List of NETCONF configuration datastores supported by
                  the NETCONF server and related information.";
               leaf name {
                  type netconf-datastore-type;
                  description
                     "Name of the datastore associated with this list entry.";
               }

               container locks {
                  presence
                     "This container is present only if the datastore
                     is locked.";
                  description
                     "The NETCONF <lock> and <partial-lock> operations allow
                     a client to lock specific resources in a datastore.  The
                     NETCONF server will prevent changes to the locked
                     resources by all sessions except the one which acquired
                     the lock(s).
                     
                     Monitoring information is provided for each datastore
                     entry including details such as the session which acquired
                     the lock, the type of lock (global or partial) and the
                     list of locked resources.  Multiple locks per datastore
                     are supported.";
                  grouping lock-info {
                     description
                        "Lock related parameters, common to both global and
                        partial locks.";
                     leaf locked-by-session {
                        type uint32;
                        mandatory "true";
                        description
                           "The session ID of the session that has locked
                           this resource.  Both a global lock and a partial
                           lock MUST contain the NETCONF session-id.
                           
                           If the lock is held by a session which is not managed
                           by the NETCONF server (e.g., a CLI session), a session
                           id of 0 (zero) is reported.";
                        reference
                           "RFC 4741: NETCONF Configuration Protocol";

                     }

                     leaf locked-time {
                        type yang:date-and-time;
                        mandatory "true";
                        description
                           "The date and time of when the resource was
                           locked.";
                     }
                  }  // grouping lock-info
                  choice lock-type {
                     description
                        "Indicates if a global lock or a set of partial locks
                        are set.";
                     container global-lock {
                        description "Present if the global lock is set.";
                        uses lock-info;
                     }  // container global-lock
                     list partial-locks {
                        key "lock-id";
                        description "List of partial locks.";
                        reference
                           "RFC 5717: Partial Lock Remote Procedure Call (RPC) for
                           	  NETCONF";

                        leaf lock-id {
                           type uint32;
                           description
                              "This is the lock id returned in the <partial-lock>
                              response.";
                        }

                        uses lock-info;

                        leaf-list select {
                           type yang:xpath1.0;
                           min-elements "1";
                           description
                              "The xpath expression which was used to request
                              the lock.  The select expression indicates the
                              original intended scope of the lock.";
                        }

                        leaf-list locked-nodes {
                           type instance-identifier;
                           description
                              "The list of instance-identifiers (i.e. the
                              locked nodes).
                              
                              The scope of the partial lock is defined by the list
                              of locked nodes.";
                        }
                     }  // list partial-locks
                  }  // choice lock-type
               }  // container locks
            }  // list datastore
         }  // container datastores

         container schemas {
            description
               "Contains the list of data model schemas supported by the
               server.";
            list schema {
               key "identifier version format";
               description
                  "List of data model schemas supported by the server.";
               leaf identifier {
                  type string;
                  description
                     "Identifier to uniquely reference the schema.  Identifier
                     is used in the <get-schema> operation and may be used for
                     other purposes such as file retrieval.
                     
                     For modeling languages which support or require a data
                     model name (eg: YANG module name) the identifier MUST
                     match that name.  For YANG data models, the identifier is
                     the name of the module or submodule.  In other cases an
                     identifier such as a filename MAY be used instead.";
               }

               leaf version {
                  type string;
                  description
                     "Version of the schema supported.  Multiple versions MAY be
                     supported simultaneously by a NETCONF server.  Each
                     version MUST be reported individually in the schema list,
                     i.e., with same identifier, possibly different location,
                     but different version.
                     
                     For YANG data models, version is the value of the most
                     recent YANG 'revision' statement in the module or
                     submodule, or the empty string if no revision statement
                     is present.";
               }

               leaf format {
                  type identityref {
                     base schema-format;
                  }
                  description
                     "The data modeling language the schema is written
                     in (currently xsd, yang, yin, rng or rnc).
                     
                     For YANG data models, 'yang' format MUST be supported and
                     'yin' format MAY also be provided.";
               }

               leaf namespace {
                  type inet:uri;
                  mandatory "true";
                  description
                     "The XML namespace defined by the data model.
                     For YANG data models, this is the module's namespace.
                     If the list entry describes a submodule, this field
                     contains the namespace of the module to which the
                     submodule belongs.";
               }

               leaf-list location {
                  type union {
                     type enumeration {
                        enum "NETCONF" {
                           value 0;
                        }
                     }
                     type inet:uri;
                  }
                  description
                     "One or more locations from which the schema can be
                     retrieved. This list SHOULD contain at least one
                     entry per schema.
                     
                     A schema entry may be located on a remote file system
                     (eg: reference to file system for ftp retrieval) or
                     retrieved directly from a server supporting the
                     <get-schema> operation (denoted by the value 'NETCONF').";
               }
            }  // list schema
         }  // container schemas

         container sessions {
            description
               "The sessions container includes session specific data for
               NETCONF management sessions.  The session list MUST include
               all currently active NETCONF sessions.";
            list session {
               key "session-id";
               description
                  "All NETCONF sessions managed by the NETCONF server
                  MUST be reported in this list.
                  
                  Any sessions not managed by the NETCONF server with
                  session identifier 0 MUST be excluded.";
               leaf session-id {
                  type uint32 {
                     range "1..max";
                  }
                  description
                     "Unique identifier for the session.  This value is the
                     NETCONF session identifier, as defined in [RFC4741].";
                  reference
                     "RFC 4741: NETCONF Configuration Protocol";

               }

               leaf transport {
                  type identityref {
                     base transport;
                  }
                  mandatory "true";
                  description
                     "Identifies the transport for each session, e.g.
                     'netconf-ssh', 'netconf-soap', etc.";
               }

               leaf username {
                  type string;
                  mandatory "true";
                  description
                     "The username is the client identity that was authenticated
                     by the NETCONF transport protocol. The algorithm used to
                     derive the username is NETCONF transport protocol specific
                     and in addition specific to the authentication mechanism
                     used by the NETCONF transport protocol.
                     
                     For NETCONF over SSH (RFC4742), the username is the
                     'user name' in the SSH_MSG_USERAUTH_REQUEST (RFC4252,
                     Section 5).
                     
                     For other transport protocols, the algorithm to derive
                     the username is implementation specific.";
               }

               leaf source-host {
                  type inet:host;
                  description
                     "Host identifier of the client.  The value returned is
                     likely to be implementation specific (e.g. hostname,
                     IP v4 address, IP v6 address)";
               }

               leaf login-time {
                  type yang:date-and-time;
                  mandatory "true";
                  description
                     "Time at which the session was established.";
               }

               uses common-counters {
                  description
                     "Per-session counters.  Zero based with following reset
                     behaviour:
                       - at start of a session
                       - when max value is reached";
               }
            }  // list session
         }  // container sessions

         container statistics {
            description
               "Statistical data pertaining to the NETCONF server.";
            leaf netconf-start-time {
               type yang:date-and-time;
               description
                  "Date and time at which the management subsystem was
                  started.";
            }

            leaf in-bad-hellos {
               type yang:zero-based-counter32;
               description
                  "Number of sessions silently dropped because an
                  invalid <hello> message was received.  This includes hello
                  messages with a 'session-id' attribute, bad namespace, and
                  bad capability declarations.";
            }

            leaf in-sessions {
               type yang:zero-based-counter32;
               description
                  "Number of sessions started.  This counter is incremented
                  when a <hello> message with a <session-id> is sent.
                  
                  'in-sessions' - 'in-bad-hellos' =
                     'number of correctly started netconf sessions'";
            }

            leaf dropped-sessions {
               type yang:zero-based-counter32;
               description
                  "Number of sessions that were abnormally terminated, e.g. due
                  to idle timeout or transport close.  This counter is not
                  incremented when a session is properly closed by a
                  <close-session> operation, or killed by a <kill-session>
                  operation.";
            }

            uses common-counters {
               description
                  "Global counters, accumulated from all sessions.
                  Zero based with following reset behaviour:
                    - re-initialization of NETCONF server
                    - when max value is reached";
            }
         }  // container statistics
      }  // container netconf-state

      rpc get-schema {
         description
            "This operation is used to retrieve a schema from the
            NETCONF server.
            
            Positive Response:
              The NETCONF server returns the requested schema.
            
            Negative Response:
              If requested schema does not exist, the <error-tag> is
              'invalid-value'.
            
              If more than one schema matches the requested parameters, the
              <error-tag> is 'operation-failed', and <error-app-tag> is
              'data-not-unique'.";
         input {
            leaf identifier {
               type string;
               mandatory "true";
               description "Identifier for the schema list entry.";
            }

            leaf version {
               type string;
               description
                  "Version of the schema requested.  If this parameter is not
                  present, and more than one version of the schema exists on
                  the server, a 'data-not-unique' error is returned, as
                  described above.";
            }

            leaf format {
               type identityref {
                  base schema-format;
               }
               description
                  "The data modeling language of the schema.  If this
                  parameter is not present, and more than one formats of
                  the schema exists on the server, a 'data-not-unique' error
                  is returned, as described above.";
            }
         }

         output {
            anyxml data {
               description "Contains the schema content.";
            }
         }
      }  // rpc get-schema
   }  // module ietf-netconf-monitoring