1002 lines
40 KiB
YANG
1002 lines
40 KiB
YANG
module H3C-ifmgr-config {
|
|
namespace "http://www.h3c.com/netconf/config:1.0-Ifmgr";
|
|
prefix "ifmgr-config";
|
|
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 config.";
|
|
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.";
|
|
}
|
|
revision 2024-07-18 {
|
|
description "Add new enumuration to Ifmgr/Interfaces/Interface/UsingType. 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 {
|
|
container TrafficStatistics {
|
|
description "TrafficStatistics sub module";
|
|
container Interval {
|
|
description "Interval table";
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..300";
|
|
}
|
|
description "Sampling interval of all interface, in seconds, in step of 5.";
|
|
}
|
|
}
|
|
}
|
|
container StormConstrain {
|
|
description "StormConstrain 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)";
|
|
}
|
|
}
|
|
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)";
|
|
}
|
|
}
|
|
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)";
|
|
}
|
|
}
|
|
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)";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
container Interval {
|
|
description "Interval Table";
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "1..300";
|
|
}
|
|
description "Traffic statistics collection interval for storm constrain, in seconds.";
|
|
}
|
|
}
|
|
}
|
|
container PortIsolation {
|
|
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";
|
|
}
|
|
}
|
|
}
|
|
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.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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 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 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 ConfigDuplex {
|
|
type enumeration {
|
|
enum 1;
|
|
enum 2;
|
|
enum 3;
|
|
}
|
|
description "This table contains storm constrain traffic collection interval information..";
|
|
}
|
|
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 MAC {
|
|
type base:Basetype_MacAddress;
|
|
}
|
|
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 ConfigBandwidth {
|
|
type base:Basetype_UnsignedInteger64 {
|
|
range "1..400000000";
|
|
}
|
|
description "Configured bandwidth of an interface(units: kbit/s).";
|
|
}
|
|
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.";
|
|
}
|
|
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 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.
|
|
enable
|
|
disable";
|
|
}
|
|
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 EthInterfaces {
|
|
description "EthInterfaces Table";
|
|
list Interface {
|
|
description "The name of Row";
|
|
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 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 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 "Config unknownUnicast 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 "UnknownUnicast 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)";
|
|
}
|
|
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 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.";
|
|
}
|
|
}
|
|
}
|
|
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 ShutdownInterval {
|
|
description "This table contains shutdown recover interval.";
|
|
leaf Interval {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "0..300";
|
|
}
|
|
description "Recover interval for interface, in seconds.";
|
|
}
|
|
}
|
|
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 is used to create or delete FlexeInstances.";
|
|
list FlexeInstance {
|
|
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";
|
|
}
|
|
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";
|
|
}
|
|
}
|
|
leaf Bandwidth {
|
|
type base:Basetype_UnsignedInteger32 {
|
|
range "5..4194303";
|
|
}
|
|
}
|
|
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_Text {
|
|
length "1..512";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
container LbnGroupGlobal {
|
|
description "This table is used to enable loadbalance ecmp lbn-group and loadbalance link-aggregation lbn-group.";
|
|
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;
|
|
}
|
|
}
|
|
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.";
|
|
}
|
|
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 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";
|
|
}
|
|
}
|
|
}
|
|
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";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|