2357 lines
102 KiB
YANG
2357 lines
102 KiB
YANG
module H3C-ifmgr-data {
|
|
namespace "http://www.h3c.com/netconf/data:1.0-Ifmgr";
|
|
prefix "ifmgr-data";
|
|
import comware-basetype {
|
|
prefix "base";
|
|
}
|
|
import comware-extension {
|
|
prefix "ext";
|
|
}
|
|
|
|
organization "NEW H3C Technologies Co., Ltd.";
|
|
contact "Website: http://www.h3c.com";
|
|
description "The module entities for ifmgr data.";
|
|
revision 2025-02-13 {
|
|
description "Modify ifmgr/Interfaces/Interface/UsingType add new type.";
|
|
reference "private";
|
|
}
|
|
revision 2024-12-27 {
|
|
description "Synchronize the modification of the schema file to the YANG file.";
|
|
}
|
|
revision 2024-10-24 {
|
|
description "Add GlobalConfig table.";
|
|
reference "private";
|
|
}
|
|
revision 2024-08-08 {
|
|
description "Add new node ifmgr/Interfaces/Interface/UsingType and InterfaceCapabilities/PortUsing.";
|
|
}
|
|
revision 2024-07-18 {
|
|
description "Add new node Ifmgr/Interfaces/Interface/AutoReduceEnable.";
|
|
}
|
|
revision 2024-06-26 {
|
|
description "Synchronize the modification of the LbnGroupGlobal to the YANG file.";
|
|
}
|
|
revision 2024-04-16 {
|
|
description "Add IfFecData LbnGroupGlobal LbnGroups";
|
|
}
|
|
revision 2022-02-17 {
|
|
description "Synchronize the modification of the schema file to the YANG file.";
|
|
}
|
|
revision 2020-05-09 {
|
|
description "Synchronize the modification of the schema file to the YANG file.";
|
|
}
|
|
revision 2020-04-07 {
|
|
description "Initial revision.";
|
|
}
|
|
container Ifmgr {
|
|
config false;
|
|
container TrafficStatistics {
|
|
config false;
|
|
description "Local time when the statistics on an interface were cleared most recently.";
|
|
container Interfaces {
|
|
description "This table contains basic interface information.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Name {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Sampling interval of all interfaces, in seconds.";
|
|
}
|
|
leaf InPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound packets during a specific period.";
|
|
}
|
|
leaf OutPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound packets during a specific period.";
|
|
}
|
|
leaf InOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound bytes during a specific period.";
|
|
}
|
|
leaf OutOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound bytes during a specific period.";
|
|
}
|
|
leaf InBits {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound bits during a specific period.";
|
|
}
|
|
leaf OutBits {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound bits during a specific period.";
|
|
}
|
|
}
|
|
}
|
|
container Interval {
|
|
description "This table contains traffic statistics interval information.";
|
|
leaf Configurable {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the sampling interval for all interface can be configured.";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Sampling interval of all interface(units: second)";
|
|
}
|
|
}
|
|
}
|
|
container StormConstrain {
|
|
config false;
|
|
description "Storm Constrain sub module";
|
|
container Interfaces {
|
|
description "This table contains interface storm constrain information.";
|
|
list Interface {
|
|
description "The Name of Row";
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index";
|
|
}
|
|
leaf CtlMode {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Storm constrain protective action
|
|
Enumeration:
|
|
0(N/A)
|
|
1(Block)
|
|
2(Shutdown)";
|
|
}
|
|
leaf Trap {
|
|
type base:Basetype_Boolean;
|
|
description "Event trap switch";
|
|
}
|
|
leaf Log {
|
|
type base:Basetype_Boolean;
|
|
description "Event log switch";
|
|
}
|
|
container Broadcast {
|
|
description "Broadcast storm constrain information of an interface";
|
|
leaf Upper {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Broadcast upper threshold value";
|
|
}
|
|
leaf Lower {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Broadcast lower threshold value";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Broadcast threshold unit:1(pps),2(ratio),3(kbps)";
|
|
}
|
|
leaf Forward {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Broadcast traffic forwarding status
|
|
Enumeration:
|
|
0(Forwarding)
|
|
1(Block)
|
|
2(Shutdown)";
|
|
}
|
|
leaf SwitchNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Number of broadcast traffic forwarding state changes";
|
|
}
|
|
}
|
|
container Multicast {
|
|
description "Multicast storm constrain information of an interface";
|
|
leaf Upper {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Multicast upper threshold value";
|
|
}
|
|
leaf Lower {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Multicast lower threshold value";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Multicast threshold unit:1(pps),2(ratio),3(kbps)";
|
|
}
|
|
leaf Forward {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Multicast traffic forwarding status
|
|
Enumeration:
|
|
0(Forwarding)
|
|
1(Block)
|
|
2(Shutdown)";
|
|
}
|
|
leaf SwitchNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Number of multicast traffic forwarding state changes";
|
|
}
|
|
}
|
|
container UnknownUnicast {
|
|
description "Unknown-unicast storm constrain information of an interface";
|
|
leaf Upper {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Unknown-unicast upper threshold value";
|
|
}
|
|
leaf Lower {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Unknown-unicast lower threshold value";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Unknown-unicast threshold unit:1(pps),2(ratio),3(kbps)";
|
|
}
|
|
leaf Forward {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Unknown-unicast traffic forwarding status
|
|
Enumeration:
|
|
0(Forwarding)
|
|
1(Block)
|
|
2(Shutdown)";
|
|
}
|
|
leaf SwitchNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Number of Unknown-unicast traffic forwarding state changes";
|
|
}
|
|
}
|
|
container KnownUnicast {
|
|
description "Known-unicast storm constrain information of an interface";
|
|
leaf Upper {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Known-unicast upper threshold value";
|
|
}
|
|
leaf Lower {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Known-unicast lower threshold value";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Known-unicast threshold unit:1(pps),2(ratio),3(kbps)";
|
|
}
|
|
leaf Forward {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Known-unicast traffic forwarding status
|
|
Enumeration:
|
|
0(Forwarding)
|
|
1(Block)
|
|
2(Shutdown)";
|
|
}
|
|
leaf SwitchNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Number of Known-unicast traffic forwarding state changes";
|
|
}
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
container Interval {
|
|
description "Interval table";
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..300";
|
|
}
|
|
description "Traffic statistics collection interval for storm constrain on all interface, in seconds.";
|
|
}
|
|
}
|
|
}
|
|
container PortIsolation {
|
|
config false;
|
|
description "Port isolate sub module";
|
|
container Groups {
|
|
description "Port isolate groups table
|
|
This table supports creating rows.";
|
|
list Group {
|
|
description "The name of Row";
|
|
key "IsolatedGroupID";
|
|
leaf IsolatedGroupID {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Isolation group ID";
|
|
}
|
|
leaf InterfaceList {
|
|
type base:Basetype_IfIndexRange;
|
|
description "Interface IfIndex list of an isolation group ID.";
|
|
}
|
|
}
|
|
}
|
|
container Interfaces {
|
|
description "Interfaces table";
|
|
list Interface {
|
|
description "The name of Row";
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index.";
|
|
}
|
|
leaf IsolatedGroupID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..max";
|
|
}
|
|
description "Port isolation group ID of an interface.";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
container Capabilities {
|
|
description "The capability of port-isolate";
|
|
leaf MaxGroupNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The maximum port isolation group number.";
|
|
}
|
|
}
|
|
}
|
|
container DataBuffer {
|
|
config false;
|
|
description "Data Buffer sub module";
|
|
container IfBuffer {
|
|
description "This table contains the buffer of interface.";
|
|
list Interface {
|
|
description "Row name";
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index";
|
|
}
|
|
leaf FreeBuf {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The number of packet buffers available for the interface.";
|
|
}
|
|
leaf InitBuf {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The number of packet buffers allocated when the interface was created.";
|
|
}
|
|
leaf MinBuf {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The smallest number of packet buffers available for the interface.";
|
|
}
|
|
leaf MissPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Broadcast storm constrain information of an interface";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container DevicePortInfo {
|
|
config false;
|
|
description "Physic interface location information.";
|
|
container Interfaces {
|
|
description "This table contains device port information.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Port {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Serial number of physic interfaces.";
|
|
}
|
|
leaf ModuleID {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Module ID of physic interfaces.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container Interfaces {
|
|
description "This table contains basic interface information.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Name {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf AbbreviatedName {
|
|
type base:Basetype_Text {
|
|
length "0..47";
|
|
}
|
|
description "Abbreviated name of an interface. String length constraints must be in range(0..47)";
|
|
}
|
|
leaf PortIndex {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Port index.";
|
|
}
|
|
leaf ifTypeExt {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..256";
|
|
}
|
|
description "Interface extension type. Numerical value must be in range(0..256).)";
|
|
}
|
|
leaf ifType {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Interface type, according to rfc 2233 MIB";
|
|
}
|
|
leaf Description {
|
|
type base:Basetype_Text {
|
|
length "0..255";
|
|
}
|
|
description "Interface description.String length constraints must be in range(0..255).";
|
|
}
|
|
leaf AdminStatus {
|
|
type base:Basetype_Integer32 {
|
|
range "1..2";
|
|
}
|
|
description "Interface administration status,as follows:
|
|
1 Admin Up
|
|
2 Admin Down";
|
|
}
|
|
leaf OperStatus {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..7";
|
|
}
|
|
description "Interface operation status as follows:
|
|
1: up
|
|
2: down
|
|
3: testing
|
|
4: unknown
|
|
5: dormant
|
|
6: notPresent
|
|
7: lowerLayerDown";
|
|
}
|
|
leaf ConfigSpeed {
|
|
type base:Basetype_UnsignedInteger64 {
|
|
range "0..1048576";
|
|
}
|
|
description "Configured speed of an interface. Each bit represents a speed as follows:
|
|
1:Auto
|
|
2:10Mbps
|
|
4:100Mbps
|
|
8:155Mbps
|
|
16:622Mbps
|
|
32:1Gbps
|
|
64:2Gbps
|
|
128:2.5Gbps
|
|
256:4Gbps
|
|
512:8Gbps
|
|
1024:10Gbps
|
|
2048:16Gbps
|
|
4096:20Gbps
|
|
8192:40Gbps
|
|
16384:100Gbps
|
|
32768:5Gbps
|
|
65536:25Gbps
|
|
131072:32Gbps
|
|
262144:50Gbps
|
|
524288:200Gbps
|
|
1048576:400Gbps)";
|
|
}
|
|
leaf ActualSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Actual speed of an interface(units: kbps).";
|
|
}
|
|
leaf ConfigDuplex {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Configured duplex mode of an interface.";
|
|
}
|
|
leaf ActualDuplex {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Actual duplex mode of an interface";
|
|
}
|
|
leaf PortLayer {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Port layer of an interface as follows:
|
|
1 Layer 2
|
|
2 Layer 3";
|
|
}
|
|
leaf LinkType {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "VLAN type of an interface as follows:
|
|
1 ACCESS
|
|
2 TRUNK
|
|
3 HYBRID";
|
|
}
|
|
leaf PVID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..4094";
|
|
}
|
|
description "Port VLAN identification (PVID) of an interface.";
|
|
}
|
|
leaf InetAddressIPV4 {
|
|
type base:Basetype_Ipv4Address;
|
|
description "Primary IPv4 address of an interface.";
|
|
}
|
|
leaf InetAddressIPV4Mask {
|
|
type base:Basetype_Ipv4Address;
|
|
description "Primary IPv4 address mask of an interface.";
|
|
}
|
|
leaf InetAddressIPV6 {
|
|
type base:Basetype_Ipv6Address;
|
|
description "Primary IPv6 address of an interface.";
|
|
}
|
|
leaf InetAddressIPV6PrefixLength {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..128";
|
|
}
|
|
description "Primary IPv6 address length of an interface.";
|
|
}
|
|
leaf PhysicalIndex {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Entity index of an interface.";
|
|
}
|
|
leaf MAC {
|
|
type base:Basetype_MacAddress;
|
|
description "MAC address of an interface.";
|
|
}
|
|
leaf ForwardingAttributes {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..63";
|
|
}
|
|
description "Forwarding attributes of an interface.";
|
|
}
|
|
leaf Loopback {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Loopback test as follows:
|
|
0 No loopback
|
|
1 Internal
|
|
2 External";
|
|
}
|
|
leaf MDI {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "MDI mode of an interface as follows:
|
|
1 MDI-II (straight-through cable)
|
|
2 MDI-X (crossover cable)
|
|
3 MDI-AUTO (auto-sensing)";
|
|
}
|
|
leaf ConfigMTU {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured MTU of an interface.";
|
|
}
|
|
leaf ActualMTU {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Actual MTU of an interface.";
|
|
}
|
|
leaf ConfigBandwidth {
|
|
type base:Basetype_UnsignedInteger64 {
|
|
range "1..400000000";
|
|
}
|
|
description "Configured bandwidth of an interface(units: kbit/s).";
|
|
}
|
|
leaf ActualBandwidth {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Actual bandwidth of an interface(units: kbit/s)";
|
|
}
|
|
leaf SubPort {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the port is sub-interface.";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..300";
|
|
}
|
|
description "Sampling interval of an interface";
|
|
}
|
|
leaf ForceUP {
|
|
type base:Basetype_Boolean;
|
|
description "Forcibly bring up an interface.";
|
|
}
|
|
leaf Actual64Bandwidth {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Actual bandwidth of an interface(units: kbit/s)";
|
|
}
|
|
container LinkDelay {
|
|
description "Physical state change suppression configuration of an interface.";
|
|
leaf UpTime {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured link-up event suppression interval of an interface(units: millisecond).";
|
|
}
|
|
leaf DownTime {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured link-down event suppression interval of an interface(units: millisecond).";
|
|
}
|
|
}
|
|
leaf KeepAlive {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..32767";
|
|
}
|
|
description "Set the hold timer of an interface";
|
|
}
|
|
leaf KeepAliveRetry {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..255";
|
|
}
|
|
description "Configured number of attempts for transmitting a keepalive message";
|
|
}
|
|
leaf DefaultMac {
|
|
type base:Basetype_MacAddress;
|
|
description "The original MAC address of the interface";
|
|
}
|
|
leaf LastChange {
|
|
type base:Basetype_OctectString;
|
|
description "From last state change time to now.";
|
|
}
|
|
leaf PhyLastChange {
|
|
type base:Basetype_OctectString;
|
|
}
|
|
leaf TrafficStatisticsEnable {
|
|
type base:Basetype_EnableState;
|
|
description "TrafficStatistics Status of the port:
|
|
enable
|
|
disable";
|
|
}
|
|
leaf SubIfRateStatisticsEnable {
|
|
type base:Basetype_EnableState;
|
|
description "Enable rate statistics collection for the subinterfaces of an Ethernet interface";
|
|
}
|
|
container ServiceSlot {
|
|
description "Primary traffic processing slot ID";
|
|
leaf Chassis {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "ID of the IRF member device where the entity resides.";
|
|
}
|
|
leaf Slot {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "Slot ID of the entity";
|
|
}
|
|
leaf Cpu {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "CPU ID";
|
|
}
|
|
}
|
|
container ServiceStandbySlot {
|
|
description "Backup traffic processing slot ID";
|
|
leaf Chassis {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "ID of the IRF member device where the entity resides";
|
|
}
|
|
leaf Slot {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "Slot ID of the entity";
|
|
}
|
|
leaf Cpu {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65535";
|
|
}
|
|
description "CPU ID";
|
|
}
|
|
}
|
|
leaf Interframe {
|
|
type base:Basetype_Boolean;
|
|
description "Include inter-frame gaps in interface statistics.";
|
|
}
|
|
leaf AutoReduceEnable {
|
|
type base:Basetype_EnableState;
|
|
description "Enable interface automatic speed reduction function:
|
|
enable
|
|
disable";
|
|
}
|
|
leaf UsingType {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
enum 4;
|
|
enum 5;
|
|
enum 6;
|
|
enum 7;
|
|
enum 8;
|
|
enum 9;
|
|
enum 10;
|
|
enum 11;
|
|
enum 12;
|
|
enum 13;
|
|
enum 14;
|
|
enum 15;
|
|
enum 16;
|
|
enum 17;
|
|
enum 18;
|
|
enum 19;
|
|
enum 20;
|
|
enum 21;
|
|
enum 22;
|
|
enum 23;
|
|
enum 24;
|
|
enum 25;
|
|
enum 26;
|
|
enum 27;
|
|
enum 28;
|
|
enum 29;
|
|
enum 30;
|
|
enum 37;
|
|
enum 38;
|
|
enum 39;
|
|
enum 40;
|
|
enum 41;
|
|
enum 42;
|
|
enum 43;
|
|
enum 44;
|
|
enum 45;
|
|
enum 46;
|
|
enum 47;
|
|
enum 48;
|
|
enum 49;
|
|
enum 50;
|
|
enum 51;
|
|
enum 52;
|
|
enum 53;
|
|
enum 54;
|
|
enum 55;
|
|
enum 56;
|
|
enum 57;
|
|
enum 58;
|
|
enum 59;
|
|
enum 60 {
|
|
description "400GETOXGE4channel";
|
|
}
|
|
enum 61 {
|
|
description "XGETO400GE";
|
|
}
|
|
}
|
|
description "Split or combine interfaces.
|
|
Each enumeration represents a switching mode:
|
|
0 UNKNOWN
|
|
1 XGETOFGE
|
|
2 XGETOHGE
|
|
3 FGETOXGE
|
|
4 HGETOXGE
|
|
5 FGETOHGE
|
|
6 HGETOFGE
|
|
7 FGETOTGE
|
|
8 TGETOFGE
|
|
9 HGETOWGE
|
|
10 WGETOHGE
|
|
11 FC16GTO32G
|
|
12 FC32GTO16G
|
|
13 400GETOHGE
|
|
14 HGETO400GE
|
|
15 400GETO50GE
|
|
16 50GETO400GE
|
|
17 400GETO200GE
|
|
18 200GETO400GE
|
|
19 200GETOHGE
|
|
20 HGETO200GE
|
|
21 200GETO25GE
|
|
22 200GETO50GE
|
|
23 400GETO25GE
|
|
24 25GETO200GE
|
|
25 50GETO200GE
|
|
26 25GETO400GE
|
|
27 HGETO50GE
|
|
28 50GETOHGE
|
|
29 XGETO200GE
|
|
30 200GETOXGE
|
|
37 400GETO2HGEchannel
|
|
38 800GETOHGE1channel
|
|
39 800GETO200GE1channel
|
|
40 800GETO400GE1channel
|
|
41 400GETOHGE1channel
|
|
42 400GETO200GE1channel
|
|
43 200GETOHGE1channel
|
|
44 800GETO400GE
|
|
45 800GETO400GE2channel
|
|
46 800GETO200GE2channel
|
|
47 400GETO200GE2channel
|
|
48 400GETO100GE2channel
|
|
49 200GETO100GE2channel
|
|
50 200GETOFGE
|
|
51 200GETOFGE1channel
|
|
52 HGETOXGE2channel
|
|
53 HGETO25GE2channel
|
|
54 HGETO800GE
|
|
55 200GETO800GE
|
|
56 400GETO800GE
|
|
57 40GETO200GE
|
|
58 800GETOHGE
|
|
59 800GETO200GE
|
|
60 400GETOXGE4channel
|
|
61 XGETO400GE";
|
|
}
|
|
}
|
|
}
|
|
container Statistics {
|
|
description "This table contains interface statistics.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Name {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf AbbreviatedName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Abbreviated name of an interface.";
|
|
}
|
|
leaf InOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound bytes on an interface.";
|
|
}
|
|
leaf InUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound unicast packets on an interface.";
|
|
}
|
|
leaf InNUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound non-unicast packets on an interface.";
|
|
}
|
|
leaf InDiscards {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of discarded inbound packets on an interface.";
|
|
}
|
|
leaf InErrors {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of errored inbound packets on an interface.";
|
|
}
|
|
leaf InUnknownProtos {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of unsupported and unknown inbound packets on an interface.";
|
|
}
|
|
leaf InRate {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound bytes on an interface.";
|
|
}
|
|
leaf OutOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound bytes on an interface.";
|
|
}
|
|
leaf OutUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound unicast packets on an interface.";
|
|
}
|
|
leaf OutNUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound non-unicast packets on an interface.";
|
|
}
|
|
leaf OutDiscards {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of discarded outbound packets on an interface.";
|
|
}
|
|
leaf OutErrors {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of errored outbound packets on an interface.";
|
|
}
|
|
leaf OutRate {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound bytes on an interface.";
|
|
}
|
|
leaf LastClear {
|
|
type base:Basetype_DateTime;
|
|
description "Local time when the statistics on an interface were cleared most recently.";
|
|
}
|
|
leaf InPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound packets on an interface.";
|
|
}
|
|
leaf OutPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound packets on an interface.";
|
|
}
|
|
leaf InPktRate {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound packets on an interface.";
|
|
}
|
|
leaf OutPktRate {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound packets on an interface.";
|
|
}
|
|
leaf InUsage {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Broadband utilization rate of inbound on an interface.";
|
|
}
|
|
leaf OutUsage {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Broadband utilization rate of outbound on an interface.";
|
|
}
|
|
}
|
|
}
|
|
container Ports {
|
|
description "This table contains port information.";
|
|
list Port {
|
|
key "PortIndex";
|
|
leaf PortIndex {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Port index as table index.";
|
|
}
|
|
leaf Name {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index";
|
|
}
|
|
}
|
|
}
|
|
container InterfaceCapabilities {
|
|
description "This table contains port capability information.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Configurable {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the interface is configurable.";
|
|
}
|
|
leaf Shutdown {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the interface can be shutdown manually.";
|
|
}
|
|
leaf Speed {
|
|
type base:Basetype_UnsignedInteger64 {
|
|
range "0..131071";
|
|
}
|
|
description "Mode s of speed which can be configured.Each bit represents a speed as follows:
|
|
1:AuTo
|
|
2:10Mbps
|
|
4:100Mbps
|
|
8:155Mbps
|
|
16:622Mbps
|
|
32:1Gbps
|
|
64:2Gbps
|
|
128:2.5Gbps
|
|
256:4Gbps
|
|
512:8Gbps
|
|
1024:10Gbps
|
|
2048:16Gbps
|
|
4096:20Gbps
|
|
8192:40Gbps
|
|
16384:100Gbps
|
|
32768:5Gbps
|
|
65536:25Gbps)";
|
|
}
|
|
leaf AutoSpeed {
|
|
type base:Basetype_UnsignedInteger64 {
|
|
range "0..7";
|
|
}
|
|
description "Modes of auto-negotiation speed which can be configured.";
|
|
}
|
|
leaf Duplex {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..7";
|
|
}
|
|
description "Modes of duplex which can be configured.";
|
|
}
|
|
leaf PortLayer {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the port layer can be changed.";
|
|
}
|
|
leaf Loopback {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the loopback test can be configured.";
|
|
}
|
|
leaf MDI {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..7";
|
|
}
|
|
description "Types of MDI which can be configured.";
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the bandwidth can be configured.";
|
|
}
|
|
leaf MinMTU {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The minimum MTU which can be configured.";
|
|
}
|
|
leaf MaxMTU {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The maximum MTU which can be configured.";
|
|
}
|
|
leaf MinSubNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Minimum sub-interface number.";
|
|
}
|
|
leaf MaxSubNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Maximum sub-interface number.";
|
|
}
|
|
leaf MaxCreateSubNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The total numbers of sub-interface which can be created.";
|
|
}
|
|
leaf ContextAllocType {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..3";
|
|
}
|
|
description "The allocation type of an interface for CONTEXT.";
|
|
}
|
|
leaf Removable {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the interface can be deleted.";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the sampling interval can be configured.";
|
|
}
|
|
leaf ForceUP {
|
|
type base:Basetype_Boolean;
|
|
description "Whether port force up can be configured.";
|
|
}
|
|
leaf LoopbackAutoStop {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the loopback detection can be auto stop.";
|
|
}
|
|
leaf MAC {
|
|
type base:Basetype_Boolean;
|
|
description "Whether MAC can be configured.";
|
|
}
|
|
leaf TrafficStatisticsEnable {
|
|
type base:Basetype_Boolean;
|
|
description "Whether interface statistics collection for interface can be configured.";
|
|
}
|
|
leaf SubIfRateStatisticsEnable {
|
|
type base:Basetype_Boolean;
|
|
description "Whether interface rate statistics collection for the subinterface of interface can be configured.";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf FlexECapability {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the interface can be switched to a flexe interface.";
|
|
}
|
|
leaf ServiceSlotCap {
|
|
type base:Basetype_Boolean;
|
|
description "Whether Service slot can be configured.";
|
|
}
|
|
leaf ServiceStandbySlotCap {
|
|
type base:Basetype_Boolean;
|
|
description "Whether Service standby slot can be configured.";
|
|
}
|
|
leaf PortUsing {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Whether interface splitting/combination is supported and its effective method after it is configured.
|
|
0 Notsupport
|
|
1 Reboot
|
|
2 Immediately";
|
|
}
|
|
}
|
|
}
|
|
container TypeCapabilities {
|
|
description "This table contains interface type capability information.";
|
|
list Capability {
|
|
key "IfTypeExt";
|
|
leaf IfTypeExt {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..256";
|
|
}
|
|
description "Interface Type.Numerical value must be in range(0..256)";
|
|
}
|
|
leaf MinNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Minimum interface number.";
|
|
}
|
|
leaf MaxNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Maximum interface number.";
|
|
}
|
|
leaf MinSubNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Minimum sub-interface number.";
|
|
}
|
|
leaf MaxSubNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Maximum sub-interface number.";
|
|
}
|
|
leaf MaxCreateNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Total interface numbers which can be created.";
|
|
}
|
|
leaf MaxCreateSubNum {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Total sub-interface numbers which can be created.";
|
|
}
|
|
leaf MAC {
|
|
type base:Basetype_Boolean;
|
|
description "Check whether a MAC address can be configured.";
|
|
}
|
|
leaf IfFullName {
|
|
type base:Basetype_String;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf IfSimpleName {
|
|
type base:Basetype_String;
|
|
description "Abbreviated name of an interface.";
|
|
}
|
|
leaf VlanTm {
|
|
type base:Basetype_Boolean;
|
|
}
|
|
}
|
|
}
|
|
container EthInterfaces {
|
|
description "This table contains ethernet interface information.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index";
|
|
}
|
|
leaf Combo {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Combo mode of an interface(1(fiber mode); 2(copper mode); 3(auto mode))";
|
|
}
|
|
leaf FlowControl {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Flow control information of an interface
|
|
1(Enable flow control)
|
|
2(Disable)
|
|
3(Only enable flow control packet receiving)";
|
|
}
|
|
leaf AutoPowerDown {
|
|
type base:Basetype_Boolean;
|
|
description "Port auto power down";
|
|
}
|
|
leaf Jumboframe {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Jumbo frame information of an interface";
|
|
}
|
|
container BroadcastSuppression {
|
|
description "Broadcast suppression information of an interface";
|
|
leaf ConfigValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured broadcast suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf ActualValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Actual broadcast suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Broadcast suppression unit:1(ratio),2(pps),3(kbps)";
|
|
}
|
|
}
|
|
container MulticastSuppression {
|
|
description "Multicast suppression information of an interface";
|
|
leaf ConfigValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured multicast suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf ActualValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Actual multicast suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "Multicast suppression unit:1(ratio),2(pps),3(kbps)";
|
|
}
|
|
leaf Flag {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Multicast suppression flag:1(all),2(unknown)";
|
|
}
|
|
}
|
|
container UnknownUnicastSuppression {
|
|
description "UnknownUnicast suppression information of an interface";
|
|
leaf ConfigValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Configured unknownUnicastUnit suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf ActualValue {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Actual unknownUnicastUnit suppression value of an interface
|
|
Value range:
|
|
ratio: 0 to 100
|
|
pps: 0 to 1.4881 * the maximum interface rate.
|
|
kbps: 0 to the maximum interface rate";
|
|
}
|
|
leaf Unit {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "UnknownUnicastUnit suppression unit:1(ratio),2(pps),3(kbps)";
|
|
}
|
|
}
|
|
leaf BPDUDrop {
|
|
type base:Basetype_Boolean;
|
|
description "Whether any type of IEEE BPDUs is drop on the port.";
|
|
}
|
|
leaf EEE {
|
|
type base:Basetype_Boolean;
|
|
description "Whether energy efficient Ethernet is enable on the port.";
|
|
}
|
|
leaf ConnectMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Port connection mode of an interface.
|
|
Enumeration:
|
|
1(Normal connection mode)
|
|
2(Extend connection mode)";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf FiberOrCopper {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Actual fiber or copper mode of an interface(1(fiber mode); 2(copper mode))";
|
|
}
|
|
container LinkFlap {
|
|
description "Link flapping information of an interface";
|
|
leaf Mode {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Interface operation status as follows:
|
|
0: noconfig
|
|
1: enable
|
|
2: disable";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..86400";
|
|
}
|
|
description "Link flapping detection interval";
|
|
}
|
|
leaf Threshold {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "2..1200";
|
|
}
|
|
description "Maximum link flapping times in detection interval";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container EthInterfaceCapabilities {
|
|
description "The capabilities of Ethernet interface";
|
|
list Interface {
|
|
description "The name of Row";
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index.";
|
|
}
|
|
leaf Combo {
|
|
type base:Basetype_Boolean;
|
|
description "Whether the fiber mode or copper mode can be activated.";
|
|
}
|
|
leaf StormConstrain {
|
|
type base:Basetype_Boolean;
|
|
description "Whether storm constrain can be configured.";
|
|
}
|
|
leaf FlowControl {
|
|
type base:Basetype_Boolean;
|
|
description "Whether flow control can be configured.";
|
|
}
|
|
leaf AutoPowerDown {
|
|
type base:Basetype_Boolean;
|
|
description "Whether auto power down can be configured.";
|
|
}
|
|
leaf MinJumboframe {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The minimum jumbofame which can be configured.";
|
|
}
|
|
leaf MaxJumboframe {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The maximum jumbofame which can be configured.";
|
|
}
|
|
leaf BPDUDrop {
|
|
type base:Basetype_Boolean;
|
|
description "Whether bpdu drop can be configured.";
|
|
}
|
|
leaf EEE {
|
|
type base:Basetype_Boolean;
|
|
description "Whether energy efficient ethernet can be configured.";
|
|
}
|
|
leaf ConnectMode {
|
|
type base:Basetype_Boolean;
|
|
description "Whether port connection mode can be configured.";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
container IfHistoryTrafficStatistics {
|
|
list TrafficStatistics {
|
|
key "IfIndex Interval TimeStamp";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
}
|
|
leaf Interval {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
}
|
|
leaf TimeStamp {
|
|
type base:Basetype_DateTime;
|
|
}
|
|
leaf InOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
}
|
|
leaf OutOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
container AllHistoryTrafficStatistics {
|
|
list TrafficStatistics {
|
|
key "Interval TimeStamp";
|
|
leaf Interval {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
}
|
|
leaf TimeStamp {
|
|
type base:Basetype_DateTime;
|
|
}
|
|
leaf InOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
}
|
|
leaf OutOctets {
|
|
type base:Basetype_UnsignedInteger64;
|
|
}
|
|
}
|
|
}
|
|
container DeviceCapabilities {
|
|
leaf HistoryTrafficStatistic {
|
|
type base:Basetype_Boolean;
|
|
}
|
|
leaf ManualNoLoopBack {
|
|
type base:Basetype_Boolean;
|
|
}
|
|
leaf DefaultShutdown {
|
|
type base:Basetype_Boolean;
|
|
}
|
|
}
|
|
container NewSubInterfaces {
|
|
description "This table is used to create or delete sub-interfaces.
|
|
This table supports creating rows.";
|
|
list Interface {
|
|
key "IfIndex SubNum";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf SubNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Sub-interface number.";
|
|
}
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
}
|
|
}
|
|
container ReserveVlanInterface {
|
|
description "This table contains the reservation of VLAN interface resources.";
|
|
list VlanInterface {
|
|
key "Type";
|
|
leaf Type {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "The reservation type:
|
|
1 Global
|
|
2 Local";
|
|
}
|
|
leaf VlanList {
|
|
type base:Basetype_VlanRange;
|
|
description "List of vlan IDs which relative vlan interface is reserved.";
|
|
ext:support-incremental "true";
|
|
}
|
|
}
|
|
}
|
|
container EthPortStatistics {
|
|
description "This table contains ethernet interface statistics.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as table index.";
|
|
}
|
|
leaf Name {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf InBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound bytes on an interface.";
|
|
}
|
|
leaf InPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound packets on an interface.";
|
|
}
|
|
leaf InUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound unicast packets on an interface.";
|
|
}
|
|
leaf InBrdcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound broadcast packets on an interface.";
|
|
}
|
|
leaf InMulticastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound multicast packets on an interface.";
|
|
}
|
|
leaf InPauses {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound pause frames on an interface.";
|
|
}
|
|
leaf InNormalBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal bytes on an interface.";
|
|
}
|
|
leaf InNormalUnicastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal unicast bytes on an interface.";
|
|
}
|
|
leaf InNormalBrdcastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal broadcast bytes on an interface.";
|
|
}
|
|
leaf InNormalMulticastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal multicast bytes on an interface.";
|
|
}
|
|
leaf InUnknownUnicastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound unknown unicast bytes on an interface.";
|
|
}
|
|
leaf InNormalPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal packets on an interface.";
|
|
}
|
|
leaf InNormalUnicastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal unicast packets on an interface.";
|
|
}
|
|
leaf InNormalBrdcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal broadcast packets on an interface.";
|
|
}
|
|
leaf InNormalMulticastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal multicast packets on an interface.";
|
|
}
|
|
leaf InUnknownUnicastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound unknown unicast packets on an interface.";
|
|
}
|
|
leaf InNormalPauses {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound normal pause frames on an interface.";
|
|
}
|
|
leaf InErrorPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of errored inbound packets on an interface.";
|
|
}
|
|
leaf InPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound packages on an interface.";
|
|
}
|
|
leaf InByteSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound bytes on an interface.";
|
|
}
|
|
leaf InBrdcastPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound broadcast packages on an interface.";
|
|
}
|
|
leaf InMulticastPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of inbound multicast packages on an interface.";
|
|
}
|
|
leaf InRunts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound runts on an interface.";
|
|
}
|
|
leaf InGiants {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound giants on an interface.";
|
|
}
|
|
leaf InThrottles {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound frames that had a non-integer number of bytes.";
|
|
}
|
|
leaf InErrCRCFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Total number of inbound frames that had a normal length, but contained CRC errors.";
|
|
}
|
|
leaf InErrFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Total number of inbound frames that contained CRC errors and a non-integer number of bytes.";
|
|
}
|
|
leaf InOverrunDropPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of packets dropped because the input rate of the port exceeded the queuing capability.";
|
|
}
|
|
leaf InAbortPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Total number of illegal inbound packets.";
|
|
}
|
|
leaf InIgnoreDropFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound frames dropped because the receiving buffer of the port ran low.";
|
|
}
|
|
leaf InParityErrFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Total number of frames with parity errors.";
|
|
}
|
|
leaf InSpeedPeakBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Peak rate of inbound traffic in Bps, and the time when the peak inbound traffic rate occurred.";
|
|
}
|
|
leaf InSpeedPeakTime {
|
|
type base:Basetype_DateTime;
|
|
description "Speed peak time of inbound bytes on an interface.";
|
|
}
|
|
leaf OutBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound bytes on an interface.";
|
|
}
|
|
leaf OutPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound packages on an interface.";
|
|
}
|
|
leaf OutUcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound unicast packets on an interface.";
|
|
}
|
|
leaf OutBrdcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound broadcast packets on an interface.";
|
|
}
|
|
leaf OutMulticastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound multicast packets on an interface.";
|
|
}
|
|
leaf OutPauses {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound pause frames on an interface.";
|
|
}
|
|
leaf OutNormalBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal bytes on an interface.";
|
|
}
|
|
leaf OutNormalUnicastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal unicast bytes on an interface.";
|
|
}
|
|
leaf OutNormalBrdcastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal broadcast bytes on an interface.";
|
|
}
|
|
leaf OutNormalMulticastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal multicast bytes on an interface.";
|
|
}
|
|
leaf OutUnknownUnicastBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound unknown unicast bytes on an interface.";
|
|
}
|
|
leaf OutNormalPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal packets on an interface.";
|
|
}
|
|
leaf OutNormalUnicastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal unicast packets on an interface.";
|
|
}
|
|
leaf OutNormalBrdcastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal broadcast packets on an interface.";
|
|
}
|
|
leaf OutNormalMulticastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal multicast packets on an interface.";
|
|
}
|
|
leaf OutUnknownUnicastPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound unknown unicast packets on an interface.";
|
|
}
|
|
leaf OutNormalPauses {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of outbound normal pause frames on an interface.";
|
|
}
|
|
leaf OutErrorPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of error outbound packets on an interface.";
|
|
}
|
|
leaf OutPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound packages on an interface.";
|
|
}
|
|
leaf OutByteSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound bytes on an interface.";
|
|
}
|
|
leaf OutBrdcastPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound broadcast packages on an interface.";
|
|
}
|
|
leaf OutMulticastPktSpeed {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Rate of outbound multicast packages on an interface.";
|
|
}
|
|
leaf OutUnderRunDropPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of packets dropped because the output rate of the interface exceeded the output queuing capability.";
|
|
}
|
|
leaf OutBuffFailDropPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of packets dropped because the transmitting buffer of the interface ran low.";
|
|
}
|
|
leaf OutAbortPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of packets that failed to be transmitted, for example, because of Ethernet collisions.";
|
|
}
|
|
leaf OutDeferedFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of frames that the interface deferred to transmit because of detected collisions.";
|
|
}
|
|
leaf OutCollisionFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of frames that the interface stopped transmitting because Ethernet collisions were detected during transmission.";
|
|
}
|
|
leaf OutLateCollisionFrames {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of frames that the interface deferred to transmit after transmitting their first 512 bits because of detected collisions.";
|
|
}
|
|
leaf OutLostCarriers {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of carrier losses during transmission.";
|
|
}
|
|
leaf OutNoCarriers {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of times that the port failed to detect the carrier when attempting to send frames.";
|
|
}
|
|
leaf OutSpeedPeakBytes {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Peak rate of outbound traffic in Bps, and the time when the peak outbound traffic rate occurred.";
|
|
}
|
|
leaf OutSpeedPeakTime {
|
|
type base:Basetype_DateTime;
|
|
description "Speed peak time of outbound bytes on an interface.";
|
|
}
|
|
}
|
|
}
|
|
container ShutdownInterval {
|
|
description "This table contains shutdown recovery interval.";
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..300";
|
|
}
|
|
description "Recover interval for interface, in seconds.";
|
|
}
|
|
}
|
|
container IfPacketDropStatistics {
|
|
description "This table contains interface dropped packets statistics.";
|
|
list Interface {
|
|
key "IfIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Interface index as IfPacketDropStatistics table index.";
|
|
}
|
|
leaf InsufficientBandDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to full GBP or insufficient bandwidth.";
|
|
}
|
|
leaf FFPDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to Fast Filter Processor.";
|
|
}
|
|
leaf STPDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to STP non-forwarding state.";
|
|
}
|
|
leaf RateLimitDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to rate-limit.";
|
|
}
|
|
leaf BroadcastBuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to broadcast-suppression.";
|
|
}
|
|
leaf UnicastBuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to unicast-suppression.";
|
|
}
|
|
leaf MulticastSuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to unicast-suppression.";
|
|
}
|
|
leaf TxDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to Tx packet aging.";
|
|
}
|
|
leaf InsufficientBuffInDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets output dropped due to insufficient data buffer.";
|
|
}
|
|
leaf InsufficientBuffOutDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets input dropped due to insufficient data buffer.";
|
|
}
|
|
}
|
|
}
|
|
container GlobalPacketDropStatistics {
|
|
description "The table contains global dropped packets statistics.";
|
|
leaf InsufficientBandDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to full GBP or insufficient bandwidth.";
|
|
}
|
|
leaf FFPDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to Fast Filter Processor.";
|
|
}
|
|
leaf STPDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to STP non-forwarding state.";
|
|
}
|
|
leaf RateLimitDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to rate-limit.";
|
|
}
|
|
leaf BroadcastBuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to broadcast-suppression.";
|
|
}
|
|
leaf UnicastBuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to unicast-suppression.";
|
|
}
|
|
leaf MulticastSuppressionDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to unicast-suppression.";
|
|
}
|
|
leaf TxDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets dropped due to Tx packet aging.";
|
|
}
|
|
leaf InsufficientBuffInDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets input dropped due to insufficient data buffer.";
|
|
}
|
|
leaf InsufficientBuffOutDrop {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Packets output dropped due to insufficient data buffer.";
|
|
}
|
|
}
|
|
container SubChannel {
|
|
description "This table contains the sub channel index info of interface.";
|
|
list Interface {
|
|
key "IfIndex CreateMode SubChannelIndex";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
}
|
|
leaf CreateMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "The channel type:
|
|
1 serial-set
|
|
2 eth-channel";
|
|
}
|
|
leaf SubChannelIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
}
|
|
}
|
|
}
|
|
container CellularChannel {
|
|
list Interface {
|
|
key "IfIndex CreateMode ChannelNum";
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
}
|
|
leaf CreateMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
}
|
|
leaf ChannelNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
}
|
|
}
|
|
}
|
|
container LinkFlap {
|
|
description "This table is used to enable link flapping protection on all physical interfaces.";
|
|
leaf Enable {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
}
|
|
description "Configure operation status as follows:
|
|
0: disable
|
|
1: enable";
|
|
}
|
|
leaf Batch {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
}
|
|
description "Configure operation status as follows:
|
|
0: disable
|
|
1: enable";
|
|
}
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..86400";
|
|
}
|
|
description "Link flapping detection interval";
|
|
}
|
|
leaf Threshold {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "2..1200";
|
|
}
|
|
description "Maximum link flapping times in detection interval";
|
|
}
|
|
}
|
|
container ShutdownAllPhyIf {
|
|
description "This table is used to shut all physical interfaces down.";
|
|
leaf Shutdown {
|
|
type base:Basetype_Boolean;
|
|
description "Shut down all physical interfaces.";
|
|
}
|
|
}
|
|
container FlexeInstances {
|
|
description "This table contains the config information of flexe.";
|
|
list FlexeInstance {
|
|
description "List of FlexeInstances for FlexeMesaage";
|
|
key "Chassis Slot Subslot";
|
|
leaf Chassis {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65534";
|
|
}
|
|
description "ID of the member where the entity resides.";
|
|
}
|
|
leaf Slot {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65534";
|
|
}
|
|
description "Slot ID of the entity.";
|
|
}
|
|
leaf Subslot {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..65534";
|
|
}
|
|
description "Subslot ID of the entity.";
|
|
}
|
|
leaf ConfigMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Bandwidth configurtion mode:
|
|
1 Bandwidth
|
|
2 TimeSlot";
|
|
}
|
|
container FlexeGroups {
|
|
description "This table contains the config information of Flexe group interfaces.";
|
|
list FlexeGroup {
|
|
description "List of FlexeGroup for Flexe group interfaces";
|
|
key "GroupID";
|
|
leaf GroupID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..1048573";
|
|
}
|
|
description "Group ID";
|
|
}
|
|
leaf IfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "Group interface ifdex";
|
|
}
|
|
container BindPhyInterfaces {
|
|
description "This table contains the config information of FlexE Physical interfaces";
|
|
list BindPhyInterface {
|
|
key "PhyIfIndex";
|
|
leaf PhyIfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "FlexeE Phyisycal Interface index";
|
|
}
|
|
leaf PhyNo {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..254";
|
|
}
|
|
description "PHY number for the FlexE Phyisycal Interface";
|
|
}
|
|
}
|
|
}
|
|
container Clients {
|
|
description "This table contains the config information of FlexE client";
|
|
list Client {
|
|
description "List of Client for FlexE client";
|
|
key "ClientID";
|
|
leaf ClientID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..65534";
|
|
}
|
|
description "FlexE Client ID";
|
|
}
|
|
leaf FlexEIfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "FlexeE Interface index";
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..4194303";
|
|
}
|
|
description "Bandwidth calue in Gbps";
|
|
}
|
|
container TimeSlots {
|
|
description "This table contains the config information of timeslots";
|
|
list TimeSlot {
|
|
key "PhyIfIndex";
|
|
leaf PhyIfIndex {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "FlexeE Phyisycal Interface index";
|
|
}
|
|
leaf TimeSlotList {
|
|
type base:Basetype_String;
|
|
description "PHY number for the FlexE Phyisycal Interface";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container ClientChannels {
|
|
description "This table contains the config information of FlexE clientchannel";
|
|
list ClientChannel {
|
|
description "List of ClientChannel for FlexE ClientChannel";
|
|
key "ClientChannelID";
|
|
leaf ClientChannelID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..65534";
|
|
}
|
|
}
|
|
leaf ClientConfigMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Bandwidth configurtion mode:
|
|
1 Bandwidth
|
|
2 TimeSlot";
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..4194303";
|
|
}
|
|
}
|
|
container TimeSlots {
|
|
description "This table contains the config information of timeslots";
|
|
list TimeSlot {
|
|
key "PhyInterface";
|
|
leaf PhyInterface {
|
|
type base:Basetype_NameAndIndexUnion;
|
|
description "FlexeE Phyisycal Interface index";
|
|
}
|
|
leaf TimeSlotList {
|
|
type base:Basetype_Text {
|
|
length "1..512";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container FG-Clients {
|
|
description "This table contains the config information of subclient";
|
|
list FG-Client {
|
|
key "FG-ClientID";
|
|
leaf FG-ClientID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..65534";
|
|
}
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "10..4194303";
|
|
}
|
|
}
|
|
leaf SubTimeSlotList {
|
|
type base:Basetype_Text {
|
|
length "1..512";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container FlexEFGInterfaces {
|
|
description "This table is used to create or delete FlexeInstances.";
|
|
list FlexEFGInterface {
|
|
key "IfName";
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf ConfigMode {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
}
|
|
description "Bandwidth configurtion mode:
|
|
1 Bandwidth
|
|
2 TimeSlot";
|
|
}
|
|
container FG-Clients {
|
|
description "This table contains the config information of FlexE client";
|
|
list FG-Client {
|
|
description "List of Client for FlexE client";
|
|
key "FG-ClientID";
|
|
leaf FG-ClientID {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..65534";
|
|
}
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "10..4194303";
|
|
}
|
|
}
|
|
leaf SubTimeSlotList {
|
|
type base:Basetype_Text {
|
|
length "1..512";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
container IfFecData {
|
|
description "This table contains ethernet fec statistics.";
|
|
list Interface {
|
|
key "IfName";
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf Correctable {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of Correctable on an interface.";
|
|
}
|
|
leaf Uncorrectable {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of Uncorrectable on an interface.";
|
|
}
|
|
}
|
|
}
|
|
|
|
container LbnGroupGlobal {
|
|
description "This table is used to enable loadbalance ecmp lbn-group,loadbalance link-aggregation lbn-group, get max lbn-group num and get max groupmember num.";
|
|
leaf EcmpEnable {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
}
|
|
description "Configure operation status as follows:
|
|
0: disable
|
|
1: enable";
|
|
}
|
|
leaf LaggEnable {
|
|
type enumeration {
|
|
enum 0;
|
|
enum 1;
|
|
}
|
|
description "Configure operation status as follows:
|
|
0: disable
|
|
1: enable";
|
|
}
|
|
leaf EcmpMode {
|
|
type string;
|
|
}
|
|
leaf LbnGroupMaxNum {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The maximum number of lbn-groups supported to be created.";
|
|
}
|
|
leaf GroupMemberMaxIndex {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "The maximum number of member ports supported by a single lbn-group";
|
|
}
|
|
}
|
|
container LbnGroups {
|
|
description "This table contains information about lbngroup and its members.";
|
|
list LbnGroup {
|
|
key "GroupName";
|
|
leaf GroupName {
|
|
type base:Basetype_String {
|
|
length "1..31";
|
|
}
|
|
description "Full name of an lbngroup.";
|
|
}
|
|
leaf GroupIndex {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Index of an lbngroup.";
|
|
}
|
|
container GroupMembers {
|
|
description "This table contains information about lbngroup members.";
|
|
list GroupMember {
|
|
description "List of GroupMember for LbnGroup";
|
|
key "InterfaceName";
|
|
leaf InterfaceName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf MemberIndex {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "Index of an groupmember.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container GlobalConfig {
|
|
description "This table contains the global configuration of the Ifmgr table.";
|
|
leaf SubIfUpDownTrapLog {
|
|
type base:Basetype_EnableState;
|
|
description "Trap and log enable State of subinterfaces:
|
|
enable
|
|
disable";
|
|
}
|
|
}
|
|
container LbnOutInterfaces {
|
|
description "This table Used to obtain the corresponding outbound interface of the specified LBN interface.";
|
|
list Interface {
|
|
key "InName IpAddress VpnInstanceName";
|
|
leaf InName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an input interface.";
|
|
}
|
|
leaf IpAddress {
|
|
type base:Basetype_IpAddress;
|
|
description "IPv4 or IPv6 address";
|
|
}
|
|
leaf VpnInstanceName {
|
|
type base:Basetype_VRF;
|
|
description "The VRF name.";
|
|
}
|
|
leaf OutName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an Output interface.";
|
|
}
|
|
}
|
|
}
|
|
container LbnInInterfaces {
|
|
description "This table Used to obtain the corresponding inbound interface of the specified LBN interface.";
|
|
list Interface {
|
|
key "OutName IpAddress VpnInstanceName Chassis Slot CPUID";
|
|
leaf OutName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an Output interface.";
|
|
}
|
|
leaf IpAddress {
|
|
type base:Basetype_IpAddress;
|
|
description "IPv4 or IPv6 address";
|
|
}
|
|
leaf VpnInstanceName {
|
|
type base:Basetype_VRF;
|
|
description "The VRF name.";
|
|
}
|
|
leaf Chassis {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Identification of the member where the entity resides as table index.";
|
|
}
|
|
leaf Slot {
|
|
type base:Basetype_UnsignedShort;
|
|
description "Slot identification of the device node as table index.";
|
|
}
|
|
leaf CPUID {
|
|
type base:Basetype_UnsignedShort;
|
|
description "CPU identification as table index";
|
|
}
|
|
leaf InPortLbnIndex {
|
|
type base:Basetype_UnsignedInteger32;
|
|
description "inport Lbn index";
|
|
}
|
|
}
|
|
}
|
|
container NakStatistics {
|
|
description "This table contains statistics for NAK packets from the interface.";
|
|
list Interface {
|
|
key "IfName";
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf Enable {
|
|
type base:Basetype_EnableState;
|
|
description "Enable interface NAK packet statistics function:
|
|
enable
|
|
disable";
|
|
}
|
|
leaf InPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound packets on an interface";
|
|
}
|
|
}
|
|
}
|
|
container CnpStatistics {
|
|
description "This table contains statistics for CNP packet from the interface.";
|
|
list Interface {
|
|
key "IfName";
|
|
leaf IfName {
|
|
type base:Basetype_InterfaceName;
|
|
description "Full name of an interface.";
|
|
}
|
|
leaf Enable {
|
|
type base:Basetype_EnableState;
|
|
description "Enable interface CNP packet statistics function:
|
|
enable
|
|
disable";
|
|
}
|
|
leaf InPkts {
|
|
type base:Basetype_UnsignedInteger64;
|
|
description "Number of inbound packets on an interface.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|