934 lines
28 KiB
YANG
934 lines
28 KiB
YANG
module openconfig-interfaces {
|
|
|
|
yang-version "1";
|
|
|
|
// namespace
|
|
namespace "http://openconfig.net/yang/interfaces";
|
|
|
|
prefix "oc-if";
|
|
|
|
// import some basic types
|
|
import ietf-interfaces { prefix ietf-if; }
|
|
import ietf-yang-types { prefix yang; }
|
|
import openconfig-extensions { prefix oc-ext; }
|
|
|
|
// meta
|
|
organization "OpenConfig working group";
|
|
|
|
contact
|
|
"OpenConfig working group
|
|
netopenconfig@googlegroups.com";
|
|
|
|
description
|
|
"Model for managing network interfaces and subinterfaces. This
|
|
module also defines convenience types / groupings for other
|
|
models to create references to interfaces:
|
|
|
|
base-interface-ref (type) - reference to a base interface
|
|
interface-ref (grouping) - container for reference to a
|
|
interface + subinterface
|
|
interface-ref-state (grouping) - container for read-only
|
|
(opstate) reference to interface + subinterface
|
|
|
|
This model reuses data items defined in the IETF YANG model for
|
|
interfaces described by RFC 7223 with an alternate structure
|
|
(particularly for operational state data) and and with
|
|
additional configuration items.";
|
|
|
|
oc-ext:openconfig-version "1.1.0";
|
|
|
|
revision "2016-12-22" {
|
|
description
|
|
"Fixes to Ethernet interfaces model";
|
|
reference "1.1.0";
|
|
}
|
|
|
|
|
|
// typedef statements
|
|
|
|
typedef base-interface-ref {
|
|
type leafref {
|
|
path "/oc-if:interfaces/oc-if:interface/oc-if:name";
|
|
}
|
|
description
|
|
"Reusable type for by-name reference to a base interface.
|
|
This type may be used in cases where ability to reference
|
|
a subinterface is not required.";
|
|
}
|
|
|
|
typedef interface-id {
|
|
type string;
|
|
description
|
|
"User-defined identifier for an interface, generally used to
|
|
name a interface reference. The id can be arbitrary but a
|
|
useful convention is to use a combination of base interface
|
|
name and subinterface index.";
|
|
}
|
|
|
|
// grouping statements
|
|
|
|
grouping interface-ref-common {
|
|
description
|
|
"Reference leafrefs to interface / subinterface";
|
|
|
|
leaf interface {
|
|
type leafref {
|
|
path "/oc-if:interfaces/oc-if:interface/oc-if:name";
|
|
}
|
|
description
|
|
"Reference to a base interface. If a reference to a
|
|
subinterface is required, this leaf must be specified
|
|
to indicate the base interface.";
|
|
}
|
|
|
|
leaf subinterface {
|
|
type leafref {
|
|
path "/oc-if:interfaces/" +
|
|
"oc-if:interface[oc-if:name=current()/../interface]/" +
|
|
"oc-if:subinterfaces/oc-if:subinterface/oc-if:index";
|
|
}
|
|
description
|
|
"Reference to a subinterface -- this requires the base
|
|
interface to be specified using the interface leaf in
|
|
this container. If only a reference to a base interface
|
|
is requuired, this leaf should not be set.";
|
|
}
|
|
}
|
|
|
|
grouping interface-ref-state-container {
|
|
description
|
|
"Reusable opstate w/container for a reference to an
|
|
interface or subinterface";
|
|
|
|
container state {
|
|
config false;
|
|
description
|
|
"Operational state for interface-ref";
|
|
|
|
uses interface-ref-common;
|
|
}
|
|
}
|
|
|
|
grouping interface-ref {
|
|
description
|
|
"Reusable definition for a reference to an interface or
|
|
subinterface";
|
|
|
|
container interface-ref {
|
|
description
|
|
"Reference to an interface or subinterface";
|
|
|
|
container config {
|
|
description
|
|
"Configured reference to interface / subinterface";
|
|
|
|
uses interface-ref-common;
|
|
}
|
|
|
|
uses interface-ref-state-container;
|
|
}
|
|
}
|
|
|
|
grouping interface-ref-state {
|
|
description
|
|
"Reusable opstate w/container for a reference to an
|
|
interface or subinterface";
|
|
|
|
container interface-ref {
|
|
description
|
|
"Reference to an interface or subinterface";
|
|
|
|
uses interface-ref-state-container;
|
|
}
|
|
}
|
|
|
|
|
|
grouping interface-common-config {
|
|
description
|
|
"Configuration data data nodes common to physical interfaces
|
|
and subinterfaces";
|
|
|
|
leaf name {
|
|
type string;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The name of the interface.
|
|
|
|
A device MAY restrict the allowed values for this leaf,
|
|
possibly depending on the type of the interface.
|
|
For system-controlled interfaces, this leaf is the
|
|
device-specific name of the interface. The 'config false'
|
|
list interfaces/interface[name]/state contains the currently
|
|
existing interfaces on the device.
|
|
|
|
If a client tries to create configuration for a
|
|
system-controlled interface that is not present in the
|
|
corresponding state list, the server MAY reject
|
|
the request if the implementation does not support
|
|
pre-provisioning of interfaces or if the name refers to
|
|
an interface that can never exist in the system. A
|
|
NETCONF server MUST reply with an rpc-error with the
|
|
error-tag 'invalid-value' in this case.
|
|
|
|
The IETF model in RFC 7223 provides YANG features for the
|
|
following (i.e., pre-provisioning and arbitrary-names),
|
|
however they are omitted here:
|
|
|
|
If the device supports pre-provisioning of interface
|
|
configuration, the 'pre-provisioning' feature is
|
|
advertised.
|
|
|
|
If the device allows arbitrarily named user-controlled
|
|
interfaces, the 'arbitrary-names' feature is advertised.
|
|
|
|
When a configured user-controlled interface is created by
|
|
the system, it is instantiated with the same name in the
|
|
/interfaces/interface[name]/state list.";
|
|
reference
|
|
"RFC 7223: A YANG Data Model for Interface Management";
|
|
}
|
|
|
|
leaf description {
|
|
type string;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
A textual description of the interface.
|
|
|
|
A server implementation MAY map this leaf to the ifAlias
|
|
MIB object. Such an implementation needs to use some
|
|
mechanism to handle the differences in size and characters
|
|
allowed between this leaf and ifAlias. The definition of
|
|
such a mechanism is outside the scope of this document.
|
|
|
|
Since ifAlias is defined to be stored in non-volatile
|
|
storage, the MIB implementation MUST map ifAlias to the
|
|
value of 'description' in the persistently stored
|
|
datastore.
|
|
|
|
Specifically, if the device supports ':startup', when
|
|
ifAlias is read the device MUST return the value of
|
|
'description' in the 'startup' datastore, and when it is
|
|
written, it MUST be written to the 'running' and 'startup'
|
|
datastores. Note that it is up to the implementation to
|
|
|
|
decide whether to modify this single leaf in 'startup' or
|
|
perform an implicit copy-config from 'running' to
|
|
'startup'.
|
|
|
|
If the device does not support ':startup', ifAlias MUST
|
|
be mapped to the 'description' leaf in the 'running'
|
|
datastore.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifAlias";
|
|
}
|
|
|
|
leaf enabled {
|
|
type boolean;
|
|
default "true";
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
This leaf contains the configured, desired state of the
|
|
interface.
|
|
|
|
Systems that implement the IF-MIB use the value of this
|
|
leaf in the 'running' datastore to set
|
|
IF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry
|
|
has been initialized, as described in RFC 2863.
|
|
|
|
Changes in this leaf in the 'running' datastore are
|
|
reflected in ifAdminStatus, but if ifAdminStatus is
|
|
changed over SNMP, this leaf is not affected.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifAdminStatus";
|
|
}
|
|
|
|
}
|
|
|
|
grouping interface-phys-config {
|
|
description
|
|
"Configuration data for physical interfaces";
|
|
|
|
leaf type {
|
|
type identityref {
|
|
base ietf-if:interface-type;
|
|
}
|
|
mandatory true;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The type of the interface.
|
|
|
|
When an interface entry is created, a server MAY
|
|
initialize the type leaf with a valid value, e.g., if it
|
|
is possible to derive the type from the name of the
|
|
interface.
|
|
|
|
If a client tries to set the type of an interface to a
|
|
value that can never be used by the system, e.g., if the
|
|
type is not supported or if the type does not match the
|
|
name of the interface, the server MUST reject the request.
|
|
A NETCONF server MUST reply with an rpc-error with the
|
|
error-tag 'invalid-value' in this case.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifType";
|
|
}
|
|
|
|
leaf mtu {
|
|
type uint16;
|
|
description
|
|
"Set the max transmission unit size in octets
|
|
for the physical interface. If this is not set, the mtu is
|
|
set to the operational default -- e.g., 1514 bytes on an
|
|
Ethernet interface.";
|
|
}
|
|
|
|
uses interface-common-config;
|
|
}
|
|
|
|
grouping interface-phys-holdtime-config {
|
|
description
|
|
"Configuration data for interface hold-time settings --
|
|
applies to physical interfaces.";
|
|
|
|
leaf up {
|
|
type uint32;
|
|
units milliseconds;
|
|
default 0;
|
|
description
|
|
"Dampens advertisement when the interface
|
|
transitions from down to up. A zero value means dampening
|
|
is turned off, i.e., immediate notification.";
|
|
}
|
|
|
|
leaf down {
|
|
type uint32;
|
|
units milliseconds;
|
|
default 0;
|
|
description
|
|
"Dampens advertisement when the interface transitions from
|
|
up to down. A zero value means dampening is turned off,
|
|
i.e., immediate notification.";
|
|
}
|
|
}
|
|
|
|
grouping interface-phys-holdtime-state {
|
|
description
|
|
"Operational state data for interface hold-time.";
|
|
}
|
|
|
|
grouping interface-phys-holdtime-top {
|
|
description
|
|
"Top-level grouping for setting link transition
|
|
dampening on physical and other types of interfaces.";
|
|
|
|
container hold-time {
|
|
description
|
|
"Top-level container for hold-time settings to enable
|
|
dampening advertisements of interface transitions.";
|
|
|
|
container config {
|
|
description
|
|
"Configuration data for interface hold-time settings.";
|
|
|
|
uses interface-phys-holdtime-config;
|
|
}
|
|
|
|
container state {
|
|
|
|
config false;
|
|
|
|
description
|
|
"Operational state data for interface hold-time.";
|
|
|
|
uses interface-phys-holdtime-config;
|
|
uses interface-phys-holdtime-state;
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping interface-common-state {
|
|
description
|
|
"Operational state data (in addition to intended configuration)
|
|
at the global level for this interface";
|
|
|
|
leaf ifindex {
|
|
type uint32;
|
|
description
|
|
"System assigned number for each interface. Corresponds to
|
|
ifIndex object in SNMP Interface MIB";
|
|
reference
|
|
"RFC 2863 - The Interfaces Group MIB";
|
|
}
|
|
|
|
leaf admin-status {
|
|
type enumeration {
|
|
enum UP {
|
|
description
|
|
"Ready to pass packets.";
|
|
}
|
|
enum DOWN {
|
|
description
|
|
"Not ready to pass packets and not in some test mode.";
|
|
}
|
|
enum TESTING {
|
|
//TODO: This is generally not supported as a configured
|
|
//admin state, though it's in the standard interfaces MIB.
|
|
//Consider removing it.
|
|
description
|
|
"In some test mode.";
|
|
}
|
|
}
|
|
//TODO:consider converting to an identity to have the
|
|
//flexibility to remove some values defined by RFC 7223 that
|
|
//are not used or not implemented consistently.
|
|
mandatory true;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The desired state of the interface. In RFC 7223 this leaf
|
|
has the same read semantics as ifAdminStatus. Here, it
|
|
reflects the administrative state as set by enabling or
|
|
disabling the interface.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifAdminStatus";
|
|
}
|
|
|
|
leaf oper-status {
|
|
type enumeration {
|
|
enum UP {
|
|
value 1;
|
|
description
|
|
"Ready to pass packets.";
|
|
}
|
|
enum DOWN {
|
|
value 2;
|
|
description
|
|
"The interface does not pass any packets.";
|
|
}
|
|
enum TESTING {
|
|
value 3;
|
|
description
|
|
"In some test mode. No operational packets can
|
|
be passed.";
|
|
}
|
|
enum UNKNOWN {
|
|
value 4;
|
|
description
|
|
"Status cannot be determined for some reason.";
|
|
}
|
|
enum DORMANT {
|
|
value 5;
|
|
description
|
|
"Waiting for some external event.";
|
|
}
|
|
enum NOT_PRESENT {
|
|
value 6;
|
|
description
|
|
"Some component (typically hardware) is missing.";
|
|
}
|
|
enum LOWER_LAYER_DOWN {
|
|
value 7;
|
|
description
|
|
"Down due to state of lower-layer interface(s).";
|
|
}
|
|
}
|
|
//TODO:consider converting to an identity to have the
|
|
//flexibility to remove some values defined by RFC 7223 that
|
|
//are not used or not implemented consistently.
|
|
mandatory true;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The current operational state of the interface.
|
|
|
|
This leaf has the same semantics as ifOperStatus.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifOperStatus";
|
|
}
|
|
|
|
leaf last-change {
|
|
type yang:timeticks;
|
|
description
|
|
"Date and time of the last state change of the interface
|
|
(e.g., up-to-down transition). This corresponds to the
|
|
ifLastChange object in the standard interface MIB.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifLastChange";
|
|
}
|
|
|
|
}
|
|
|
|
|
|
grouping interface-counters-state {
|
|
description
|
|
"Operational state representing interface counters
|
|
and statistics. Some of these are adapted from RFC 7223";
|
|
|
|
//TODO: we may need to break this list of counters into those
|
|
//that would appear for physical vs. subinterface or logical
|
|
//interfaces. For now, just replicating the full stats
|
|
//grouping to both interface and subinterface.
|
|
|
|
container counters {
|
|
description
|
|
"A collection of interface-related statistics objects.";
|
|
|
|
reference
|
|
"RFC 7223 - A YANG Data Model for Interface
|
|
Management";
|
|
|
|
leaf in-octets {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The total number of octets received on the interface,
|
|
including framing characters.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifHCInOctets";
|
|
}
|
|
|
|
leaf in-unicast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The number of packets, delivered by this sub-layer to a
|
|
higher (sub-)layer, that were not addressed to a
|
|
multicast or broadcast address at this sub-layer.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifHCInUcastPkts";
|
|
}
|
|
|
|
leaf in-broadcast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The number of packets, delivered by this sub-layer to a
|
|
higher (sub-)layer, that were addressed to a broadcast
|
|
address at this sub-layer.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB -
|
|
ifHCInBroadcastPkts";
|
|
}
|
|
|
|
leaf in-multicast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
|
|
The number of packets, delivered by this sub-layer to a
|
|
higher (sub-)layer, that were addressed to a multicast
|
|
address at this sub-layer. For a MAC-layer protocol,
|
|
this includes both Group and Functional addresses.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB -
|
|
ifHCInMulticastPkts";
|
|
}
|
|
|
|
leaf in-discards {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
The number of inbound packets that were chosen to be
|
|
discarded even though no errors had been detected to
|
|
prevent their being deliverable to a higher-layer
|
|
protocol. One possible reason for discarding such a
|
|
packet could be to free up buffer space.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
|
|
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifInDiscards";
|
|
}
|
|
|
|
leaf in-errors {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
For packet-oriented interfaces, the number of inbound
|
|
packets that contained errors preventing them from being
|
|
deliverable to a higher-layer protocol. For character-
|
|
oriented or fixed-length interfaces, the number of
|
|
inbound transmission units that contained errors
|
|
preventing them from being deliverable to a higher-layer
|
|
protocol.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifInErrors";
|
|
}
|
|
|
|
leaf in-unknown-protos {
|
|
type yang:counter32;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
For packet-oriented interfaces, the number of packets
|
|
received via the interface that were discarded because
|
|
of an unknown or unsupported protocol. For
|
|
character-oriented or fixed-length interfaces that
|
|
support protocol multiplexing, the number of
|
|
transmission units received via the interface that were
|
|
discarded because of an unknown or unsupported protocol.
|
|
For any interface that does not support protocol
|
|
multiplexing, this counter is not present.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifInUnknownProtos";
|
|
}
|
|
|
|
leaf out-octets {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
The total number of octets transmitted out of the
|
|
interface, including framing characters.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifHCOutOctets";
|
|
}
|
|
|
|
leaf out-unicast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The total number of packets that higher-level protocols
|
|
requested be transmitted, and that were not addressed
|
|
to a multicast or broadcast address at this sub-layer,
|
|
including those that were discarded or not sent.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifHCOutUcastPkts";
|
|
}
|
|
|
|
leaf out-broadcast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
|
|
The total number of packets that higher-level protocols
|
|
requested be transmitted, and that were addressed to a
|
|
broadcast address at this sub-layer, including those
|
|
that were discarded or not sent.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB -
|
|
ifHCOutBroadcastPkts";
|
|
}
|
|
|
|
|
|
leaf out-multicast-pkts {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
The total number of packets that higher-level protocols
|
|
requested be transmitted, and that were addressed to a
|
|
multicast address at this sub-layer, including those
|
|
that were discarded or not sent. For a MAC-layer
|
|
protocol, this includes both Group and Functional
|
|
addresses.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB -
|
|
ifHCOutMulticastPkts";
|
|
}
|
|
|
|
leaf out-discards {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
The number of outbound packets that were chosen to be
|
|
discarded even though no errors had been detected to
|
|
prevent their being transmitted. One possible reason
|
|
for discarding such a packet could be to free up buffer
|
|
space.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifOutDiscards";
|
|
}
|
|
|
|
leaf out-errors {
|
|
type yang:counter64;
|
|
description
|
|
"[adapted from IETF interfaces model (RFC 7223)]
|
|
Changed the counter type to counter64.
|
|
|
|
For packet-oriented interfaces, the number of outbound
|
|
packets that could not be transmitted because of errors.
|
|
For character-oriented or fixed-length interfaces, the
|
|
number of outbound transmission units that could not be
|
|
transmitted because of errors.
|
|
|
|
Discontinuities in the value of this counter can occur
|
|
at re-initialization of the management system, and at
|
|
other times as indicated by the value of
|
|
'discontinuity-time'.";
|
|
reference
|
|
"RFC 2863: The Interfaces Group MIB - ifOutErrors";
|
|
}
|
|
|
|
leaf last-clear {
|
|
type yang:date-and-time;
|
|
description
|
|
"Indicates the last time the interface counters were
|
|
cleared.";
|
|
}
|
|
}
|
|
}
|
|
|
|
// data definition statements
|
|
|
|
grouping sub-unnumbered-config {
|
|
description
|
|
"Configuration data for unnumbered subinterfaces";
|
|
|
|
leaf enabled {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Indicates that the subinterface is unnumbered. By default
|
|
the subinterface is numbered, i.e., expected to have an
|
|
IP address configuration.";
|
|
}
|
|
}
|
|
|
|
grouping sub-unnumbered-state {
|
|
description
|
|
"Operational state data unnumbered subinterfaces";
|
|
}
|
|
|
|
grouping sub-unnumbered-top {
|
|
description
|
|
"Top-level grouping unnumbered subinterfaces";
|
|
|
|
container unnumbered {
|
|
description
|
|
"Top-level container for setting unnumbered interfaces.
|
|
Includes reference the interface that provides the
|
|
address information";
|
|
|
|
container config {
|
|
description
|
|
"Configuration data for unnumbered interface";
|
|
|
|
uses sub-unnumbered-config;
|
|
}
|
|
|
|
container state {
|
|
|
|
config false;
|
|
|
|
description
|
|
"Operational state data for unnumbered interfaces";
|
|
|
|
uses sub-unnumbered-config;
|
|
uses sub-unnumbered-state;
|
|
}
|
|
|
|
uses oc-if:interface-ref;
|
|
}
|
|
}
|
|
|
|
grouping subinterfaces-config {
|
|
description
|
|
"Configuration data for subinterfaces";
|
|
|
|
leaf index {
|
|
type uint32;
|
|
default 0;
|
|
description
|
|
"The index of the subinterface, or logical interface number.
|
|
On systems with no support for subinterfaces, or not using
|
|
subinterfaces, this value should default to 0, i.e., the
|
|
default subinterface.";
|
|
}
|
|
|
|
uses interface-common-config;
|
|
|
|
}
|
|
|
|
grouping subinterfaces-state {
|
|
description
|
|
"Operational state data for subinterfaces";
|
|
|
|
uses interface-common-state;
|
|
uses interface-counters-state;
|
|
}
|
|
|
|
grouping subinterfaces-top {
|
|
description
|
|
"Subinterface data for logical interfaces associated with a
|
|
given interface";
|
|
|
|
container subinterfaces {
|
|
description
|
|
"Enclosing container for the list of subinterfaces associated
|
|
with a physical interface";
|
|
|
|
list subinterface {
|
|
key "index";
|
|
|
|
description
|
|
"The list of subinterfaces (logical interfaces) associated
|
|
with a physical interface";
|
|
|
|
leaf index {
|
|
type leafref {
|
|
path "../config/index";
|
|
}
|
|
description
|
|
"The index number of the subinterface -- used to address
|
|
the logical interface";
|
|
}
|
|
|
|
container config {
|
|
description
|
|
"Configurable items at the subinterface level";
|
|
|
|
uses subinterfaces-config;
|
|
}
|
|
|
|
container state {
|
|
|
|
config false;
|
|
description
|
|
"Operational state data for logical interfaces";
|
|
|
|
uses subinterfaces-config;
|
|
uses subinterfaces-state;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grouping interfaces-top {
|
|
description
|
|
"Top-level grouping for interface configuration and
|
|
operational state data";
|
|
|
|
container interfaces {
|
|
description
|
|
"Top level container for interfaces, including configuration
|
|
and state data.";
|
|
|
|
|
|
list interface {
|
|
key "name";
|
|
|
|
description
|
|
"The list of named interfaces on the device.";
|
|
|
|
leaf name {
|
|
type leafref {
|
|
path "../config/name";
|
|
}
|
|
description
|
|
"References the configured name of the interface";
|
|
//TODO: need to consider whether this should actually
|
|
//reference the name in the state subtree, which
|
|
//presumably would be the system-assigned name, or the
|
|
//configured name. Points to the config/name now
|
|
//because of YANG 1.0 limitation that the list
|
|
//key must have the same "config" as the list, and
|
|
//also can't point to a non-config node.
|
|
}
|
|
|
|
container config {
|
|
description
|
|
"Configurable items at the global, physical interface
|
|
level";
|
|
|
|
uses interface-phys-config;
|
|
}
|
|
|
|
container state {
|
|
|
|
config false;
|
|
description
|
|
"Operational state data at the global interface level";
|
|
|
|
uses interface-phys-config;
|
|
uses interface-common-state;
|
|
uses interface-counters-state;
|
|
}
|
|
|
|
uses interface-phys-holdtime-top;
|
|
uses subinterfaces-top;
|
|
}
|
|
}
|
|
}
|
|
|
|
uses interfaces-top;
|
|
|
|
|
|
}
|