Difference: YangExamplesNetconfStateHtml (1 vs. 6)

Revision 62011-02-15 - MartinBjoerklund

Line: 1 to 1
 
META TOPICPARENT name="YangExamples"
Changed:
<
<
module netconf-state {

>
>
module ietf-netconf-monitoring {

 
Changed:
<
<
namespace "urn:ietf:params:xml:ns:netconf:state"; prefix "ns";
>
>
namespace "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring"; prefix "ncm";
 
Changed:
<
<
import yang-types { prefix yang; } import inet-types { prefix inet; }
>
>
import ietf-yang-types { prefix yang; } import ietf-inet-types { prefix inet; }
  organization
Changed:
<
<
"IETF";
>
>
"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.
Changed:
<
<
All elements in this module are read-only.";
>
>
All elements in this module are read-only.
 
Changed:
<
<
revision "2008-11-03" { description "Initial revision."; }
>
>
Copyright (c) 2010 IETF Trust and the persons identified as authors of the code. All rights reserved.
 
Changed:
<
<
typedef SessionId? { type uint32 { range "1..max";
>
>
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 6022; see the RFC itself for full legal notices.";

revision 2010-10-04 { description "Initial revision."; reference "RFC 6022: YANG Module for NETCONF Monitoring";

  }
Changed:
<
<
reference "rfc4741";
>
>
typedef foo { type string;
  }
Changed:
<
<
grouping NETCONFDatastoreType? {
>
>
typedef netconf-datastore-type { type enumeration { enum running; enum candidate; enum startup; }
  description "Enumeration of possible NETCONF datastore types.";
Changed:
<
<
reference "rfc4741"; choice datastore { mandatory true; leaf running { type empty;
>
>
reference "RFC 4741: NETCONF Configuration Protocol";
  }
Changed:
<
<
leaf candidate { type empty;
>
>
identity transport { description "Base identity for NETCONF transport types.";
  }
Changed:
<
<
leaf startup { type empty;
>
>
identity netconf-ssh { base transport; description "NETCONF over Secure Shell (SSH)."; reference "RFC 4742: Using the NETCONF Configuration Protocol over Secure SHell (SSH)";
  }
Added:
>
>
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)";
  }
Added:
>
>
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)";
  }
Changed:
<
<
typedef TransportType? { type enumeration { enum "SSH"; enum "SSL"; enum "Console"; enum "HTTP"; enum "HTTPS";
>
>
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)";
  }
Added:
>
>
identity netconf-tls { base transport; description "NETCONF over Transport Layer Security (TLS)."; reference "RFC 5539: NETCONF over Transport Layer Security (TLS)";
  }
Changed:
<
<
typedef ProtocolType? { type enumeration { enum "CLI"; enum "NETCONF"; enum "WebUI";
>
>
identity schema-format { description "Base identity for data model schema languages.";
  }
Added:
>
>
identity xsd { base schema-format; description "W3C XML Schema Definition."; reference "W3C REC REC-xmlschema-1-20041028: XML Schema Part 1: Structures";
  }
Changed:
<
<
typedef SchemaFormat? { type enumeration { enum "XSD" { reference "W3C REC REC-xmlschema-1-20041028";
>
>
identity yang { base schema-format; description "The YANG data modeling language for NETCONF."; reference "RFC 6020: YANG - A Data Modeling Language for the Network Configuration Protocol (NETCONF)";
  }
Changed:
<
<
enum "YANG" { reference "draft-ietf-netmod-yang";
>
>
identity yin { base schema-format; description "The YIN syntax for YANG."; reference "RFC 6020: YANG - A Data Modeling Language for the Network Configuration Protocol (NETCONF)"; }

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

identity rnc { base schema-format; description "Relax NG Compact Syntax"; reference "ISO/IEC 19757-2:2008: 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.";

  }
Changed:
<
<
enum "RNG" { reference "ISO/IEC 19757-2";
>
>
leaf in-bad-rpcs { type yang:zero-based-counter32; description "Number of messages received when an <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 that contained an <rpc-error> element.";
  }
Added:
>
>
leaf out-notifications { type yang:zero-based-counter32; description "Number of <notification> messages sent.";
  } }
Changed:
<
<
container netconf {
>
>
container netconf-state {
  config false;
Added:
>
>
description "The netconf-state container is the root of the monitoring data model.";
  container capabilities { description
Changed:
<
<
"The list of currently provided NETCONF capabilities. This may be different than those exchanged during session setup (i.e. hello).";
>
>
"Contains the list of NETCONF capabilities supported by the server.";
  leaf-list capability { type inet:uri;
Changed:
<
<
min-elements 1;
>
>
description "List of NETCONF capabilities supported by the server.";
  } }
Changed:
<
<
container configurations {
>
>
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
Changed:
<
<
"List of NETCONF configuration datastores (e.g. running, startup, candidate) supported on this device and related information."; list configuration { container name { uses NETCONFDatastoreType? ;
>
>
"Name of the datastore associated with this list entry.";
  } container locks {
Added:
>
>
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 that acquired the lock(s).

Monitoring information is provided for each datastore entry including details such as the session that 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
Changed:
<
<
"An indication of whether a resource is locked or unlocked. If locked, additional information about the locking such as user an time stamp is provided.";

grouping LockInfo? { leaf lockedBySession { type SessionId? ;

>
>
"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
Changed:
<
<
this resource.";
>
>
this resource. Both a global lock and a partial lock MUST contain the NETCONF session-id.

If the lock is held by a session that 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";

  }
Changed:
<
<
leaf lockedTime {
>
>
leaf locked-time {
  type yang:date-and-time;
Added:
>
>
mandatory true;
  description "The date and time of when the resource was locked."; } }
Changed:
<
<
choice lockType { container globalLock {
>
>
choice bb { case aa { leaf aa { type string ; }} } choice lock-type { description "Indicates if a global lock or a set of partial locks are set.";

case foo { container global-lock {

  description "Present if the global lock is set.";
Changed:
<
<
uses LockInfo? ;
>
>
uses lock-info;
  }
Changed:
<
<
list partialLocks { key lockId;
>
>
leaf bar { type string; }}

list partial-lock { key lock-id;

  description
Changed:
<
<
"Present if at least one partial lock is set.";
>
>
"List of partial locks."; reference "RFC 5717: Partial Lock Remote Procedure Call (RPC) for NETCONF";
 
Changed:
<
<
leaf lockId {
>
>
leaf lock-id {
  type uint32;
Added:
>
>
description "This is the lock id returned in the <partial-lock> response.";
  }
Changed:
<
<
uses LockInfo? ;
>
>
uses lock-info;
  leaf-list select {
Changed:
<
<
type string;
>
>
type yang:xpath1.0;
  min-elements 1; description
Changed:
<
<
"The xpath expression which was used to request the lock.";
>
>
"The xpath expression that was used to request the lock. The select expression indicates the original intended scope of the lock.";
  }
Changed:
<
<
leaf-list lockedNodes {
>
>
leaf-list locked-node {
  type instance-identifier; description
Changed:
<
<
"The list of instance-identifiers (i.e. the locked nodes).";
>
>
"The list of instance-identifiers (i.e., the locked nodes).

The scope of the partial lock is defined by the list of locked nodes.";

  } } }
Line: 156 to 332
  }

container schemas {

Added:
>
>
description "Contains the list of data model schemas supported by the server.";
  list schema {
Changed:
<
<
key "identifier format version";
>
>
key "identifier version format";

description "List of data model schemas supported by the server.";

  leaf identifier { type string; description
Changed:
<
<
"Identifier to uniquely reference the schema";
>
>
"Identifier to uniquely reference the schema. The identifier is used in the <get-schema> operation and may be used for other purposes such as file retrieval.

For modeling languages that support or require a data model name (e.g., 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
Changed:
<
<
"Version of the schema supported. Multiple versions can be supported simultaneously.";
>
>
"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 {
Changed:
<
<
type SchemaFormat? ;
>
>
type identityref { base schema-format; }
  description
Changed:
<
<
"Schema language for the file/module.";
>
>
"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;
Added:
>
>
mandatory true;
  description
Changed:
<
<
"The XML namespace defined by the data model.";
>
>
"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.";

  }
Changed:
<
<
leaf location {
>
>
leaf-list location {
  type union { type enumeration { enum "NETCONF";
Line: 187 to 398
  type inet:uri; } description
Changed:
<
<
"A location from which the schema can be retrieved. Can be either on the network device retrievable explicitly via the get-schema netconf operation (denoted by the value 'NETCONF') or some network location (i.e. URL).";
>
>
"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 (e.g., reference to file system for ftp retrieval) or retrieved directly from a server supporting the <get-schema> operation (denoted by the value 'NETCONF').";

  } } }

container sessions { description

Changed:
<
<
"List of NETCONF sessions currently active on this device.";
>
>
"The sessions container includes session-specific data for NETCONF management sessions. The session list MUST include all currently active NETCONF sessions.";
  list session {
Changed:
<
<
key sessionId; leaf sessionId { type SessionId? ; } leaf transport { type TransportType? ; } leaf protocol { type ProtocolType? ; } leaf username { type string; } leaf sourceHost { type inet:host; } leaf loginTime { type yang:date-and-time;
>
>
key session-id;
  description
Changed:
<
<
"Time at which the session was established.";
>
>
"All NETCONF sessions managed by the NETCONF server MUST be reported in this list.";

leaf session-id { type uint32 { range "1..max";

  }
Added:
>
>
description "Unique identifier for the session. This value is the NETCONF session identifier, as defined in RFC 4741."; reference "RFC 4741: NETCONF Configuration Protocol";
  }
Added:
>
>
leaf transport { type identityref { base transport;
  }
Changed:
<
<
container subscriptions { description "Contains information on the active subscriptions on the NETCONF server. Subscriptions which have ended are not reported."; list subscription { key sessionId; description "Information about Netconf Notification Subscriptions."; leaf sessionId { type SessionId? ;
>
>
mandatory true;
  description
Changed:
<
<
"The session id associated with this subscription.";
>
>
"Identifies the transport for each session, e.g., 'netconf-ssh', 'netconf-soap', etc.";
  }
Changed:
<
<
leaf stream {
>
>
leaf username {
  type string;
Added:
>
>
mandatory true;
  description
Changed:
<
<
"The stream associated with this subscription."; } anyxml filter { description "The filters associated with this subscription.";
>
>
"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.";
  }
Changed:
<
<
leaf startTime { type yang:date-and-time;
>
>
leaf source-host { type inet:host;
  description
Changed:
<
<
"The startTime parameter from the create-subscription invokation, if it was present.";
>
>
"Host identifier of the NETCONF client. The value returned is implementation specific (e.g., hostname, IPv4 address, IPv6 address)";
  }
Changed:
<
<
leaf stopTime {
>
>
leaf login-time {
  type yang:date-and-time;
Added:
>
>
mandatory true;
  description
Changed:
<
<
"The stopTime parameter from the create-subscription invokation, if it was present.";
>
>
"Time at the server at which the session was established.";
  }
Changed:
<
<
leaf messagesSent { type yang:zero-based-counter32;
>
>
uses common-counters {
  description
Changed:
<
<
"A count of event notifications sent along this connection since the subscription was created.";
>
>
"Per-session counters. Zero based with following reset behaviour: - at start of a session - when max value is reached";
  } } }

container statistics {

Deleted:
<
<
leaf netconfStartTime { type yang:date-and-time; description "Date and time at which the NETCONF server process was started. Allows for calculation of time interval for reported metrics."; } leaf inSessions { type yang:zero-based-counter32;
  description
Changed:
<
<
"The total number of NETCONF sessions started towards the NETCONF peer.
>
>
"Statistical data pertaining to the NETCONF server.";
 
Changed:
<
<
inSessions - inBadHellos = 'number of correctly started netconf sessions'"; } leaf inXMLParseErrors { type yang:zero-based-counter32;
>
>
leaf netconf-start-time { type yang:date-and-time;
  description
Changed:
<
<
"The total number of messages that were unparsable and thus ignored. This covers both unparsable 'hello' and 'rpc' messages.";
>
>
"Date and time at which the management subsystem was started.";
  }
Changed:
<
<
leaf inBadHellos {
>
>
leaf in-bad-hellos {
  type yang:zero-based-counter32; description
Changed:
<
<
"The total number of sessions silently dropped because an invalid 'hello' message was received. This includes hello
>
>
"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."; }
Changed:
<
<
leaf inRpcs {
>
>
leaf in-sessions {
  type yang:zero-based-counter32; description
Changed:
<
<
"The total number of rpc requests received."; } leaf inBadRpcs { type yang:zero-based-counter32; description "The total number of rpcs which were parsed correctly, but couldn't be serviced because they contained non-conformant XML, e.g. missing a mandatory parameter.";
>
>
"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'";

  }
Changed:
<
<
leaf inNotSupportedRpcs {
>
>
leaf dropped-sessions {
  type yang:zero-based-counter32; description
Changed:
<
<
"The total number of rpcs which were parsed correctly, but couldn't be serviced because they were not supported by the agent.";
>
>
"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";
  }
Deleted:
<
<
leaf outRpcReplies { type yang:zero-based-counter32; description "The total number of 'rpc-reply' messages sent.";
  }
Deleted:
<
<
leaf outRpcErrors { type yang:zero-based-counter32; description "The total number of 'rpc-reply' messages with 'rpc-error' sent.";
  }
Changed:
<
<
leaf outNotifications { type yang:zero-based-counter32;
>
>
rpc get-schema {
  description
Changed:
<
<
"The total number of 'notifications' messages sent."; } }
>
>
"This operation is used to retrieve a schema from the NETCONF server.
 
Changed:
<
<
}
>
>
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'.";

 
Deleted:
<
<
rpc get-schema {
  input { leaf identifier { type string; mandatory true;
Added:
>
>
description "Identifier for the schema list entry.";
  } leaf version { type string;
Changed:
<
<
mandatory true;
>
>
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 {
Changed:
<
<
type SchemaFormat? ; mandatory true;
>
>
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 {
Changed:
<
<
description "Contains the schema content.";
>
>
description "Contains the schema content.";
  } } }

Revision 52008-11-04 - MartinBjoerklund

Line: 1 to 1
 
META TOPICPARENT name="YangExamples"
Changed:
<
<
module netconf-state {

>
>
module netconf-state {

 
Changed:
<
<
namespace "urn:ietf:params:xml:ns:netconf:state:1.0";
>
>
namespace "urn:ietf:params:xml:ns:netconf:state";
  prefix "ns";

import yang-types { prefix yang; }

Line: 13 to 12
  "IETF";

description

Changed:
<
<
"NetConf Monitoring Schema. All elements in this Schema are read-only.";
>
>
"NETCONF Monitoring Module. All elements in this module are read-only.";
 
Changed:
<
<
revision "2008-02-01" { description "Updated to match draft-bjorklund-netconf-yang-01"; } revision "2007-11-12" { description "Updated to match draft-scott-netconf-monitoring-00.txt"; } revision "2007-07-22" {
>
>
revision "2008-11-03" {
  description "Initial revision."; }

typedef SessionId? { type uint32 {

Changed:
<
<
range "1..4294967295";
>
>
range "1..max";
  } reference "rfc4741"; }
Changed:
<
<
typedef ConfigName? { type enumeration { enum "running"; enum "candidate"; enum "startup"; }
>
>
grouping NETCONFDatastoreType? { description "Enumeration of possible NETCONF datastore types.";
  reference "rfc4741";
Added:
>
>
choice datastore { mandatory true; leaf running { type empty; } leaf candidate { type empty; } leaf startup { type empty; } }
  }
Changed:
<
<
typedef transportType {
>
>
typedef TransportType? {
  type enumeration {
Changed:
<
<
enum "console"; enum "tcp"; enum "ssh"; enum "ssl";
>
>
enum "SSH"; enum "SSL"; enum "Console"; enum "HTTP"; enum "HTTPS";
  } }
Changed:
<
<
typedef sessionType {
>
>
typedef ProtocolType? {
  type enumeration {
Changed:
<
<
enum "cli"; enum "netconf"; enum "webui";
>
>
enum "CLI"; enum "NETCONF"; enum "WebUI";
  } }
Changed:
<
<
grouping srcIdentifier { description "Information about source of the session."; leaf ipAddressTypev4 { type inet:ipv4-address;
>
>
typedef SchemaFormat? { type enumeration { enum "XSD" { reference "W3C REC REC-xmlschema-1-20041028"; } enum "YANG" { reference "draft-ietf-netmod-yang"; } enum "RNG" { reference "ISO/IEC 19757-2";
  }
Deleted:
<
<
leaf nodeName { type string; description "Name of the node.";
  } }
Changed:
<
<
container netconfState {
>
>
container netconf {
  config false;

container capabilities { description

Changed:
<
<
"List of NETCONF capabilities supported by this device.";
>
>
"The list of currently provided NETCONF capabilities. This may be different than those exchanged during session setup (i.e. hello).";
  leaf-list capability {
Changed:
<
<
type yang:uri;
>
>
type inet:uri;
  min-elements 1; } }
Deleted:
<
<
container sessions { description "List of NETCONF sessions currently active on this device."; list session { key sessionId; leaf sessionId { type SessionId? ; } leaf transport { type transportType; } leaf username { type string; } container sourceIdentifier { uses srcIdentifier; } leaf loginTime { type yang:date-and-time; } } }
  container configurations { description "List of NETCONF configuration datastores (e.g. running, startup, candidate) supported on this device and related information.";
Changed:
<
<
list config { key name; leaf name { type ConfigName? ; } container lockStatus {
>
>
list configuration { container name { uses NETCONFDatastoreType? ; } container locks {
  description "An indication of whether a resource is locked or unlocked. If locked, additional information about the locking such as user an time stamp is provided.";
Changed:
<
<
leaf lock-state { type enumeration { enum "locked"; enum "unlocked"; } }
>
>
grouping LockInfo? {
  leaf lockedBySession { type SessionId? ; description
Line: 129 to 116
  type yang:date-and-time; description "The date and time of when the resource was
Changed:
<
<
locked. If the resource is currently unlocked, this element will not be present.";
>
>
locked."; } }

choice lockType { container globalLock { description "Present if the global lock is set."; uses LockInfo? ; } list partialLocks { key lockId; description "Present if at least one partial lock is set.";

leaf lockId { type uint32; }

uses LockInfo? ; leaf-list select { type string; min-elements 1; description "The xpath expression which was used to request the lock."; } leaf-list lockedNodes { type instance-identifier; description "The list of instance-identifiers (i.e. the locked nodes)."; } } } } } }

container schemas { list schema { key "identifier format version"; leaf identifier { type string; description "Identifier to uniquely reference the schema"; } leaf version { type string; description "Version of the schema supported. Multiple versions can be supported simultaneously."; } leaf format { type SchemaFormat? ; description "Schema language for the file/module."; } leaf namespace { type inet:uri; description "The XML namespace defined by the data model."; } leaf location { type union { type enumeration { enum "NETCONF"; } type inet:uri; } description "A location from which the schema can be retrieved. Can be either on the network device retrievable explicitly via the get-schema netconf operation (denoted by the value 'NETCONF') or some network location (i.e. URL)."; } } }

container sessions { description "List of NETCONF sessions currently active on this device."; list session { key sessionId; leaf sessionId { type SessionId? ; } leaf transport { type TransportType? ; } leaf protocol { type ProtocolType? ; } leaf username { type string; } leaf sourceHost { type inet:host; } leaf loginTime { type yang:date-and-time; description "Time at which the session was established.";

  } } }

container subscriptions { description

Changed:
<
<
"List of NETCONF notification subscriptions active on this device and related information.";
>
>
"Contains information on the active subscriptions on the NETCONF server. Subscriptions which have ended are not reported.";
  list subscription {
Changed:
<
<
key session-id;
>
>
key sessionId;
  description "Information about Netconf Notification Subscriptions.";
Changed:
<
<
leaf session-id {
>
>
leaf sessionId {
  type SessionId? ; description "The session id associated with this subscription.";
Line: 157 to 246
  description "The filters associated with this subscription."; }
Added:
>
>
leaf startTime { type yang:date-and-time; description "The startTime parameter from the create-subscription invokation, if it was present."; } leaf stopTime { type yang:date-and-time; description "The stopTime parameter from the create-subscription invokation, if it was present."; }
  leaf messagesSent { type yang:zero-based-counter32; description
Line: 166 to 267
  } } }
Added:
>
>
container statistics { leaf netconfStartTime { type yang:date-and-time; description "Date and time at which the NETCONF server process was started. Allows for calculation of time interval for reported metrics."; } leaf inSessions { type yang:zero-based-counter32; description "The total number of NETCONF sessions started towards the NETCONF peer.

inSessions - inBadHellos = 'number of correctly started netconf sessions'"; } leaf inXMLParseErrors { type yang:zero-based-counter32; description "The total number of messages that were unparsable and thus ignored. This covers both unparsable 'hello' and 'rpc' messages.";

  }
Added:
>
>
leaf inBadHellos { type yang:zero-based-counter32; description "The total 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.";
  }
Added:
>
>
leaf inRpcs { type yang:zero-based-counter32; description "The total number of rpc requests received."; } leaf inBadRpcs { type yang:zero-based-counter32; description "The total number of rpcs which were parsed correctly, but couldn't be serviced because they contained non-conformant XML, e.g. missing a mandatory parameter."; } leaf inNotSupportedRpcs { type yang:zero-based-counter32; description "The total number of rpcs which were parsed correctly, but couldn't be serviced because they were not supported by the agent."; } leaf outRpcReplies { type yang:zero-based-counter32; description "The total number of 'rpc-reply' messages sent."; } leaf outRpcErrors { type yang:zero-based-counter32; description "The total number of 'rpc-reply' messages with 'rpc-error' sent."; } leaf outNotifications { type yang:zero-based-counter32; description "The total number of 'notifications' messages sent."; } }

}

rpc get-schema { input { leaf identifier { type string; mandatory true; } leaf version { type string; mandatory true; } leaf format { type SchemaFormat? ; mandatory true; } } output { anyxml data { description "Contains the schema content."; } } }

 } \ No newline at end of file

Revision 42008-02-01 - MartinBjoerklund

Line: 1 to 1
 
META TOPICPARENT name="YangExamples"
module netconf-state {

Line: 16 to 16
  "NetConf Monitoring Schema. All elements in this Schema are read-only.";
Added:
>
>
revision "2008-02-01" { description "Updated to match draft-bjorklund-netconf-yang-01"; }
  revision "2007-11-12" { description "Updated to match draft-scott-netconf-monitoring-00.txt";
Line: 90 to 94
  key sessionId; leaf sessionId { type SessionId? ; } leaf transport { type transportType; }
Deleted:
<
<
leaf protocol { type sessionType; }
  leaf username { type string; } container sourceIdentifier { uses srcIdentifier; } leaf loginTime { type yang:date-and-time; }
Line: 150 to 153
  description "The stream associated with this subscription."; }
Changed:
<
<
leaf filter { type anyxml;
>
>
anyxml filter {
  description "The filters associated with this subscription."; }

Revision 32007-11-20 - MartinBjoerklund

Line: 1 to 1
 
META TOPICPARENT name="YangExamples"
module netconf-state {

Line: 90 to 90
  key sessionId; leaf sessionId { type SessionId? ; } leaf transport { type transportType; }
Added:
>
>
leaf protocol { type sessionType; }
  leaf username { type string; } container sourceIdentifier { uses srcIdentifier; } leaf loginTime { type yang:date-and-time; }

Revision 22007-11-15 - MartinBjoerklund

Line: 1 to 1
 
META TOPICPARENT name="YangExamples"
module netconf-state {

Line: 6 to 6
  namespace "urn:ietf:params:xml:ns:netconf:state:1.0"; prefix "ns";
Changed:
<
<
import yang-types { prefix yang; }
>
>
import yang-types { prefix yang; } import inet-types { prefix inet; }
  organization "IETF";
Line: 17 to 16
  "NetConf Monitoring Schema. All elements in this Schema are read-only.";
Added:
>
>
revision "2007-11-12" { description "Updated to match draft-scott-netconf-monitoring-00.txt"; }
  revision "2007-07-22" { description "Initial revision."; }
Line: 37 to 40
  reference "rfc4741"; }
Added:
>
>
typedef transportType { type enumeration { enum "console"; enum "tcp"; enum "ssh"; enum "ssl"; } }

typedef sessionType { type enumeration { enum "cli"; enum "netconf"; enum "webui"; } }

grouping srcIdentifier { description "Information about source of the session."; leaf ipAddressTypev4 { type inet:ipv4-address; } leaf nodeName { type string; description "Name of the node."; } }

  container netconfState { config false;
Line: 44 to 76
  description "List of NETCONF capabilities supported by this device.";
Changed:
<
<
leaf-list capability { type yang:uri; }
>
>
leaf-list capability { type yang:uri; min-elements 1; }
  }

container sessions {

Line: 53 to 88
  active on this device."; list session { key sessionId;
Changed:
<
<
leaf sessionId { type SessionId? ; }
>
>
leaf sessionId { type SessionId? ; } leaf transport { type transportType; }
  leaf username { type string; }
Added:
>
>
container sourceIdentifier { uses srcIdentifier; }
  leaf loginTime { type yang:date-and-time; } } }

Revision 12007-11-05 - MartinBjoerklund

Line: 1 to 1
Added:
>
>
META TOPICPARENT name="YangExamples"
module netconf-state {

    namespace "urn:ietf:params:xml:ns:netconf:state:1.0";
    prefix "ns";

    import yang-types {
        prefix yang;
    }

    organization
        "IETF";

    description
        "NetConf Monitoring Schema.
         All elements in this Schema are read-only.";

    revision "2007-07-22" {
        description "Initial revision.";
    }

    typedef SessionId {
        type uint32 {
            range "1..4294967295";
        }
        reference "rfc4741";
    }

    typedef ConfigName {
        type enumeration {
            enum "running";
            enum "candidate";
            enum "startup";
        }
        reference "rfc4741";
    }

    container netconfState {
        config false;

        container capabilities {
            description 
                "List of NETCONF capabilities supported
                 by this device.";
            leaf-list capability { type yang:uri; }
        }

        container sessions {
            description
                "List of NETCONF sessions currently
                 active on this device.";
            list session {
                key sessionId;
                leaf sessionId {
                    type SessionId;
                }
                leaf username  { type string; }
                leaf loginTime { type yang:date-and-time; }
            }
        }

        container configurations {
            description
                "List of NETCONF configuration datastores (e.g. running,
                 startup, candidate) supported on this device and related
                 information.";
            list config {
                key name;
                leaf name { type ConfigName; }
                container lockStatus {
                    description
                        "An indication of whether a resource is locked or
                         unlocked.  If locked, additional information about
                         the locking such as user an time stamp is provided.";
                    leaf lock-state {
                        type enumeration {
                            enum "locked";
                            enum "unlocked";
                        }
                    }
                    leaf lockedBySession {
                        type SessionId;
                        description 
                            "The session ID of the session that has locked
                             this resource.";
                    }
                    leaf lockedTime {
                        type yang:date-and-time;
                        description
                            "The date and time of when the resource was
                             locked. If the resource is currently unlocked,
                             this element will not be present.";
                    }
                }
            }

            container subscriptions {
                description
                    "List of NETCONF notification subscriptions
                     active on this device and related information.";
                list subscription {
                    key session-id;
                    description
                        "Information about Netconf Notification Subscriptions.";
                    leaf session-id {
                        type SessionId;
                        description
                            "The session id associated with this subscription.";
                    }
                    leaf stream {
                        type string;
                        description
                            "The stream associated with this subscription.";
                    }
                    leaf filter {
                        type anyxml;
                        description 
                            "The filters associated with this subscription.";
                    }
                    leaf messagesSent {
                        type yang:zero-based-counter32;
                        description
                            "A count of event notifications sent along
                             this connection since the subscription was
                             created.";
                    }
                }
            }
        }
    }
}
 
This site is powered by the TWiki collaboration platformCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback