mirror of
https://github.com/hsnodgrass/snmp_mib_archive.git
synced 2025-04-17 16:03:04 +00:00
1074 lines
38 KiB
Plaintext
1074 lines
38 KiB
Plaintext
-- *****************************************************************
|
|
-- CISCO-L4L7MODULE-REDUNDANCY-MIB.my:
|
|
-- Redundancy MIB for Service Modules using
|
|
-- a Cisco Proprietary Protocol.
|
|
--
|
|
-- Mar 2008, Umayal Ramanathan
|
|
--
|
|
-- Copyright (c) 2008 by cisco Systems Inc.
|
|
-- All rights reserved.
|
|
-- *****************************************************************
|
|
|
|
CISCO-L4L7MODULE-REDUNDANCY-MIB DEFINITIONS ::= BEGIN
|
|
|
|
IMPORTS
|
|
MODULE-IDENTITY,
|
|
NOTIFICATION-TYPE,
|
|
OBJECT-TYPE,
|
|
Unsigned32,
|
|
Counter64
|
|
FROM SNMPv2-SMI
|
|
MODULE-COMPLIANCE,
|
|
OBJECT-GROUP,
|
|
NOTIFICATION-GROUP
|
|
FROM SNMPv2-CONF
|
|
InetAddressType,
|
|
InetAddress
|
|
FROM INET-ADDRESS-MIB
|
|
TEXTUAL-CONVENTION,
|
|
TimeStamp,
|
|
TruthValue,
|
|
RowStatus,
|
|
StorageType
|
|
FROM SNMPv2-TC
|
|
InterfaceIndex,
|
|
InterfaceIndexOrZero
|
|
FROM IF-MIB
|
|
entPhysicalIndex
|
|
FROM ENTITY-MIB
|
|
ciscoMgmt
|
|
FROM CISCO-SMI;
|
|
|
|
|
|
ciscoL4L7moduleRedundancyMIB MODULE-IDENTITY
|
|
LAST-UPDATED "200804040000Z"
|
|
ORGANIZATION "Cisco Systems, Inc."
|
|
CONTACT-INFO
|
|
"Cisco Systems
|
|
Customer Service
|
|
|
|
Postal: 170 W. Tasman Drive
|
|
San Jose, CA 95134
|
|
USA
|
|
|
|
Tel: +1 800 553-NETS
|
|
|
|
E-mail: cs-l4l7security@cisco.com"
|
|
DESCRIPTION
|
|
"The L4-7 SLB devices are used
|
|
for scaling websites, building web
|
|
enabled applications, and migrating
|
|
to web services. The following services
|
|
( but not limited to ) can be provided by
|
|
L4-7 slb devices:
|
|
SLB ( Server Load Balancing )
|
|
FW ( Firewall )
|
|
SSL ( Secure Socket Layer )
|
|
IDS ( Intrusion Detection System ) .
|
|
|
|
This MIB provides the tables/objects that
|
|
support redundancy configuration and
|
|
redundancy statistics.
|
|
|
|
The redundancy model supported by this MIB
|
|
allows two or more SLB devices to be
|
|
configured with one or more redundancy
|
|
group. Each redundancy group is identified by
|
|
a unique group ID. Two or more devices are
|
|
redundant to each other if they use the
|
|
same redundancy Group ID.
|
|
|
|
Acronyms and terms:
|
|
HB Heart Beat
|
|
FT Fault Tolerant
|
|
HA High Availability
|
|
VLAN Virtual Local Area Network
|
|
LB Load Balance"
|
|
REVISION "200804040000Z"
|
|
DESCRIPTION
|
|
"Added a new state 'warmCompatible' to
|
|
clrPeerSoftwareCompatibilty
|
|
Added a new state 'standbyWarm' to ciscoL4L7RedState."
|
|
REVISION "200803130000Z"
|
|
DESCRIPTION
|
|
"Initial version of this MIB module."
|
|
::= { ciscoMgmt 650 }
|
|
|
|
|
|
ciscoLmRedundancyMIBNotifs OBJECT IDENTIFIER
|
|
::= { ciscoL4L7moduleRedundancyMIB 0 }
|
|
|
|
ciscoLmRedundancyMIBObjects OBJECT IDENTIFIER
|
|
::= { ciscoL4L7moduleRedundancyMIB 1 }
|
|
|
|
ciscoLmRedundancyMIBConformance OBJECT IDENTIFIER
|
|
::= { ciscoL4L7moduleRedundancyMIB 2 }
|
|
|
|
clrConfig OBJECT IDENTIFIER
|
|
::= { ciscoLmRedundancyMIBObjects 1 }
|
|
|
|
clrStats OBJECT IDENTIFIER
|
|
::= { ciscoLmRedundancyMIBObjects 2 }
|
|
|
|
clrNotifObjects OBJECT IDENTIFIER
|
|
::= { ciscoLmRedundancyMIBObjects 3 }
|
|
|
|
|
|
CiscoL4L7RedState ::= TEXTUAL-CONVENTION
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The redundancy state of the device
|
|
in redundancy configuration.
|
|
'other' : other than values defined below.
|
|
'nonRedundant' : redundancy has not been configured.
|
|
'initializing' : establish necessary system services
|
|
'negotiation' : peer unit discovery and negotiation
|
|
'active' : device is in active state. It is
|
|
servicing the requests.
|
|
'standbyCold' : standby will take over if
|
|
synchronization is failed using
|
|
bulk synch mechanism.
|
|
'standbyConfig' : The active device receives a
|
|
notification to send a snapshot of its
|
|
running-config to the local standby
|
|
device.
|
|
'standbyBulk' : The active device receives a
|
|
notification to send a snapshot of the
|
|
current state information for all
|
|
applications to the standby device.
|
|
'standbyHot' : Incremental data synchronization
|
|
continues. This unit is ready and is
|
|
able to instantly take over activity.
|
|
'standbyWarm' : When the peer software compatibility
|
|
is warmCompatible ( a state in
|
|
clrPeerSoftwareCompatibility ) , the
|
|
redundant groups on standby goes to
|
|
standbyWarm instead of standbyHot.
|
|
Whether the bulk config sync
|
|
fails/passes the transition to
|
|
standbyBulk is always made
|
|
and eventually the standby device goes
|
|
to standbyWarm. The standbyWarm state is
|
|
similar to standbyHot state ( config
|
|
mode will be locked, state replication/
|
|
config sync are continued ) , but when
|
|
config-sync failed, there is no move to
|
|
standbyCold state."
|
|
SYNTAX INTEGER {
|
|
other(1),
|
|
nonRedundant(2),
|
|
initializing(3),
|
|
negotiation(4),
|
|
active(5),
|
|
standbyCold(6),
|
|
standbyConfig(7),
|
|
standbyBulk(8),
|
|
standbyHot(9),
|
|
standbyWarm(10)
|
|
}
|
|
|
|
clrPeerConfigTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrPeerConfigEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table is for configuring peer groups that are
|
|
part of redundancy configuration. The peer configuration
|
|
specifies the information used for exchanging High
|
|
Availability information related to redundancy groups."
|
|
::= { clrConfig 1 }
|
|
|
|
clrPeerConfigEntry OBJECT-TYPE
|
|
SYNTAX ClrPeerConfigEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"An entry in clrPeerConfigTable. Each entry contains information
|
|
about peer interface, query interface, heart beat
|
|
count and heart beat time."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrPeerId
|
|
}
|
|
::= { clrPeerConfigTable 1 }
|
|
|
|
ClrPeerConfigEntry ::= SEQUENCE {
|
|
clrPeerId Unsigned32,
|
|
clrPeerInterface InterfaceIndex,
|
|
clrPeerBackupInterface InterfaceIndexOrZero,
|
|
clrPeerHeartBeatTime Unsigned32,
|
|
clrPeerHeartBeatCount Unsigned32,
|
|
clrPeerStorageType StorageType,
|
|
clrPeerRowStatus RowStatus
|
|
}
|
|
|
|
clrPeerId OBJECT-TYPE
|
|
SYNTAX Unsigned32 (1..65535 )
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object identifies unique id for the peer.
|
|
The peer is used in redundancy configuration."
|
|
::= { clrPeerConfigEntry 1 }
|
|
|
|
clrPeerInterface OBJECT-TYPE
|
|
SYNTAX InterfaceIndex
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object specifies the interface used by the
|
|
peers to exchange High Availability ( HA ) protocol
|
|
information."
|
|
::= { clrPeerConfigEntry 2 }
|
|
|
|
clrPeerBackupInterface OBJECT-TYPE
|
|
SYNTAX InterfaceIndexOrZero
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object specifies the backup interface used by the
|
|
peer. The backup interface is used in case the heart beat
|
|
message is not received. This interface is used to
|
|
send the heart beat message. If the message sent is not
|
|
successful, then it is assumed peer is down and switchover
|
|
will be initiated. If the message sent is successful
|
|
on this interface, the peer transitions to standbyCold
|
|
and continue to monitor peer."
|
|
DEFVAL { 0 }
|
|
::= { clrPeerConfigEntry 3 }
|
|
|
|
clrPeerHeartBeatTime OBJECT-TYPE
|
|
SYNTAX Unsigned32
|
|
UNITS "milliseconds"
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The time interval between heartbeat/keep-alive
|
|
messages exchanged between the peers."
|
|
DEFVAL { 1 }
|
|
::= { clrPeerConfigEntry 4 }
|
|
|
|
clrPeerHeartBeatCount OBJECT-TYPE
|
|
SYNTAX Unsigned32
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object is used in conjunction with
|
|
'clrPeerHeartBeatTime' to switch over the active
|
|
redundancy unit or not. Switch over occurs if
|
|
heartbeats are not received from the peer
|
|
during a specific time period, which
|
|
is equal to ( clrPeerHeartBeatTime *
|
|
clrPeerHeartBeatCount ) ."
|
|
DEFVAL { 1 }
|
|
::= { clrPeerConfigEntry 5 }
|
|
|
|
clrPeerStorageType OBJECT-TYPE
|
|
SYNTAX StorageType
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The storage type for this conceptual row."
|
|
DEFVAL { nonVolatile }
|
|
::= { clrPeerConfigEntry 6 }
|
|
|
|
clrPeerRowStatus OBJECT-TYPE
|
|
SYNTAX RowStatus
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object is used for adding/deleting
|
|
entries from the table.
|
|
|
|
An entry MUST NOT exist in the active state unless all
|
|
objects in the entry have an appropriate value, as described
|
|
in the description clause for each writable object.
|
|
|
|
This object may be modified if the associated
|
|
instance of this object is equal to active(1),
|
|
notInService(2), or notReady(3). All other writable objects
|
|
may be modified if the associated instance of this object is
|
|
equal to notInService(2) or notReady(3)."
|
|
::= { clrPeerConfigEntry 7 }
|
|
|
|
|
|
|
|
clrPeerInfoTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrPeerInfoEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table contains information of the redundancy peer."
|
|
::= { clrConfig 2 }
|
|
|
|
clrPeerInfoEntry OBJECT-TYPE
|
|
SYNTAX ClrPeerInfoEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"An entry in peer information table. An entry will get created
|
|
whenever an entry is created in clrPeerConfigTable. Each entry
|
|
contains information such as peer state, peer ip address,
|
|
software and license compatibility. The entPhysicalIndex
|
|
specifies an entry in entPhysicalTable with entPhysicalClass
|
|
representing the value of 'module'."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrPeerId
|
|
}
|
|
::= { clrPeerInfoTable 1 }
|
|
|
|
ClrPeerInfoEntry ::= SEQUENCE {
|
|
clrPeerOperStatus INTEGER,
|
|
clrPeerIpAddressType InetAddressType,
|
|
clrPeerIpAddress InetAddress,
|
|
clrPeerSoftwareCompatibilty INTEGER,
|
|
clrPeerLicenseCompatibility INTEGER,
|
|
clrPeerRedGroups Unsigned32
|
|
}
|
|
|
|
clrPeerOperStatus OBJECT-TYPE
|
|
SYNTAX INTEGER {
|
|
init(1),
|
|
localIPaddr(2),
|
|
peerIPAddr(3),
|
|
startHB(4),
|
|
tcpSetup(5),
|
|
srgCheck(6),
|
|
licCheck(7),
|
|
compatible(8),
|
|
peerInterfaceDown(9),
|
|
down(10),
|
|
error(11)
|
|
}
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object identifies the current status of the peer. The
|
|
possible values are
|
|
|
|
init(1) : The initial state of the peer.
|
|
localIPaddr(2) : The local device IP address is missing.
|
|
Waiting for the local IP address
|
|
to be configured.
|
|
peerIPAddr(3) : The peer IP address is missing. Waiting
|
|
for the peer IP address to be configured.
|
|
startHB(4) : The peer configuration is complete.
|
|
Starting the heartbeat to see if there
|
|
is a peer device.
|
|
tcpSetUp(5) : The heartbeat has detected the presence
|
|
of the peer device. Redundancy is in
|
|
the process of establishing a TCP
|
|
connection to the peer.
|
|
srgCheck(6) : Checking for software version
|
|
compatibility with the peer device.
|
|
licCheck(7) : Checking for license compatibility with
|
|
the peer device.
|
|
compatible(8) : Version and license checks indicate that
|
|
the peer is compatible for redundancy.
|
|
peerInterfaceDown(9): The peer interface ( used for transmitting
|
|
and receiving HB messages ) is down,
|
|
but, through the query interface,
|
|
the local device has determined that
|
|
the peer is still alive.
|
|
down(10) : The peer device is down.
|
|
error(11) : Indicates that an error has occurred
|
|
with the peer. Possible errors are:
|
|
version mismatch, license mismatch,
|
|
or failure to establish a TCP connection
|
|
to the peer. A syslog message appears
|
|
with more detailed information."
|
|
::= { clrPeerInfoEntry 1 }
|
|
|
|
clrPeerIpAddressType OBJECT-TYPE
|
|
SYNTAX InetAddressType
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The type of internet address by which the
|
|
peer is reachable."
|
|
::= { clrPeerInfoEntry 2 }
|
|
|
|
clrPeerIpAddress OBJECT-TYPE
|
|
SYNTAX InetAddress
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This Internet address for the redundant peer.
|
|
The type of this address is determined by the
|
|
value of the clrPeerIpAddressType object."
|
|
::= { clrPeerInfoEntry 3 }
|
|
|
|
clrPeerSoftwareCompatibilty OBJECT-TYPE
|
|
SYNTAX INTEGER {
|
|
init(1),
|
|
compatible(2),
|
|
inCompatible(3),
|
|
warmCompatible(4)
|
|
}
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Indicates whether the software version of the local device
|
|
and the software version of the peer are compatible. The
|
|
possible values are:
|
|
init(1) : initialization state.
|
|
compatible(2) : software version of the local and peer
|
|
device are compatible.
|
|
inCompatible(3) : software version of the local and peer
|
|
device are not compatible.
|
|
warmCompatible(4) : When the software version check of the
|
|
local and the peer device returns
|
|
'supersedes' or 'superseded_by'
|
|
then the clrPeerSoftwarecompatibility of
|
|
the peer device is set to 'warmCompatible'."
|
|
::= { clrPeerInfoEntry 4 }
|
|
|
|
clrPeerLicenseCompatibility OBJECT-TYPE
|
|
SYNTAX INTEGER {
|
|
init(1),
|
|
compatible(2),
|
|
inCompatible(3)
|
|
}
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Indicates whether the license of the local device and the
|
|
license of the peer device are compatible. The possible
|
|
values are:
|
|
init(1) : initialization state.
|
|
compatible(2) : license version of the local and peer
|
|
device are compatible.
|
|
inCompatible(3) : license version of the local and peer
|
|
device are not compatible."
|
|
::= { clrPeerInfoEntry 5 }
|
|
|
|
clrPeerRedGroups OBJECT-TYPE
|
|
SYNTAX Unsigned32
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object refers to the number of redundancy groups the peer
|
|
is associated with."
|
|
DEFVAL { 0 }
|
|
::= { clrPeerInfoEntry 6 }
|
|
|
|
|
|
|
|
clrRedundancyConfigTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrRedundancyConfigEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table is used for configuring
|
|
redundancy groups. The redundancy group
|
|
is configured by specifying the same
|
|
value of 'clrRedGroupId' in multiple devices."
|
|
::= { clrConfig 3 }
|
|
|
|
clrRedundancyConfigEntry OBJECT-TYPE
|
|
SYNTAX ClrRedundancyConfigEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"An entry in redundancy table.
|
|
Each entry contains information such
|
|
as priority, preempt. Preemption
|
|
ensures that the group member with high priority
|
|
always becomes active. The entPhysicalIndex
|
|
specifies the entry in entPhysicalTable with
|
|
entPhysicalClass representing the value of 'module'."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrRedGroupId
|
|
}
|
|
::= { clrRedundancyConfigTable 1 }
|
|
|
|
ClrRedundancyConfigEntry ::= SEQUENCE {
|
|
clrRedGroupId Unsigned32,
|
|
clrRedPeerId Unsigned32,
|
|
clrRedPriority Unsigned32,
|
|
clrRedPreempt TruthValue,
|
|
clrRedFailOverTime Unsigned32,
|
|
clrRedState CiscoL4L7RedState,
|
|
clrRedStateChangeTime TimeStamp,
|
|
clrRedContext OCTET STRING,
|
|
clrRedStorageType StorageType,
|
|
clrRedRowStatus RowStatus
|
|
}
|
|
|
|
clrRedGroupId OBJECT-TYPE
|
|
SYNTAX Unsigned32 (1..4096 )
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object specifies the redundancy group
|
|
identifier. This is the unique id of the
|
|
redundancy group."
|
|
::= { clrRedundancyConfigEntry 1 }
|
|
|
|
clrRedPeerId OBJECT-TYPE
|
|
SYNTAX Unsigned32 (1..65535 )
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The peer ID to which this group belongs.
|
|
There must be an entry in clrPeerConfigTable
|
|
with this value. This object cannot be modified
|
|
if the associated clrRedRowStatus object is equal
|
|
to 'active'."
|
|
::= { clrRedundancyConfigEntry 2 }
|
|
|
|
clrRedPriority OBJECT-TYPE
|
|
SYNTAX Unsigned32 (1..255 )
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The priority value of the redundancy group.
|
|
This value is used in selecting the active
|
|
and standby peer.
|
|
|
|
The devices that belong to the same
|
|
redundancy group must be configured with a different
|
|
priority. The redundancy group with a highest
|
|
priority will become active unit during
|
|
negotiation phase of the redundancy.
|
|
If two (or more) devices in a group have
|
|
the same priority, the one with the highest IP address
|
|
of the interface is the active device.
|
|
|
|
If a redundancy group with high priority
|
|
value is online after its peer has become
|
|
active, then the group with high priority
|
|
will become standby. This behavior can be
|
|
changed by setting clrRedPreempt object to
|
|
'true'."
|
|
DEFVAL { 10 }
|
|
::= { clrRedundancyConfigEntry 3 }
|
|
|
|
clrRedPreempt OBJECT-TYPE
|
|
SYNTAX TruthValue
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This specifies whether a high priority
|
|
redundancy device can become active irrespective
|
|
of the time at which it is online.
|
|
|
|
The value 'true' specifies that the redundancy
|
|
group with higher priority will always become active.
|
|
|
|
The value 'false' specifies that the redundacy
|
|
device which becomes active will remain active
|
|
even if another redundancy device comes online
|
|
with higher priority."
|
|
DEFVAL { true }
|
|
::= { clrRedundancyConfigEntry 4 }
|
|
|
|
clrRedFailOverTime OBJECT-TYPE
|
|
SYNTAX Unsigned32
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The time to wait before standby redundancy
|
|
group become active. This represents the amount
|
|
of time a module need to wait after the last
|
|
keep-alive message is received before assuming
|
|
the peer is not operating."
|
|
DEFVAL { 3 }
|
|
::= { clrRedundancyConfigEntry 5 }
|
|
|
|
clrRedState OBJECT-TYPE
|
|
SYNTAX CiscoL4L7RedState
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The current redundancy state."
|
|
::= { clrRedundancyConfigEntry 6 }
|
|
|
|
clrRedStateChangeTime OBJECT-TYPE
|
|
SYNTAX TimeStamp
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The time of the last change in the current
|
|
redundancy state."
|
|
::= { clrRedundancyConfigEntry 7 }
|
|
|
|
clrRedContext OBJECT-TYPE
|
|
SYNTAX OCTET STRING
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object refers to the context name to which the redundant
|
|
group is associated with. The context refers to the logical
|
|
partitioning within a device. The context can be identified
|
|
by a unique name in a device."
|
|
::= { clrRedundancyConfigEntry 8 }
|
|
|
|
clrRedStorageType OBJECT-TYPE
|
|
SYNTAX StorageType
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The storage type for this conceptual row."
|
|
DEFVAL { nonVolatile }
|
|
::= { clrRedundancyConfigEntry 9 }
|
|
|
|
clrRedRowStatus OBJECT-TYPE
|
|
SYNTAX RowStatus
|
|
MAX-ACCESS read-create
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object is used for adding/deleting
|
|
entries from the table.
|
|
|
|
An entry MUST NOT exist in the active state unless all
|
|
objects in the entry have an appropriate value, as described
|
|
in the description clause for each writable object.
|
|
|
|
This object may be modified if the associated
|
|
instance of this object is equal to active(1),
|
|
notInService(2), or notReady(3). All other writable objects
|
|
may be modified if the associated instance of this object is
|
|
equal to notInService(2) or notReady(3)."
|
|
::= { clrRedundancyConfigEntry 10 }
|
|
|
|
|
|
|
|
clrRedundancyInfoTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrRedundancyInfoEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table contains information on the
|
|
devices that are part of redundancy group."
|
|
::= { clrConfig 4 }
|
|
|
|
clrRedundancyInfoEntry OBJECT-TYPE
|
|
SYNTAX ClrRedundancyInfoEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"An entry in redundancy information table.
|
|
An entry will get created whenever an
|
|
entry is created in clrRedundancyConfigTable.
|
|
Each entry contains information such
|
|
as priority, state and last time
|
|
when the redundancy state got changed.
|
|
The entPhysicalIndex specifies an entry in
|
|
entPhysicalTable with entPhysicalClass representing
|
|
the value of 'module'."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrRedGroupId
|
|
}
|
|
::= { clrRedundancyInfoTable 1 }
|
|
|
|
ClrRedundancyInfoEntry ::= SEQUENCE {
|
|
clrRedundancyPriority Unsigned32,
|
|
clrRedundancyState CiscoL4L7RedState,
|
|
clrRedundancyStateChangeTime TimeStamp,
|
|
clrRedundancyIpAddressType InetAddressType,
|
|
clrRedundancyIpAddress InetAddress
|
|
}
|
|
|
|
clrRedundancyPriority OBJECT-TYPE
|
|
SYNTAX Unsigned32 (1..255 )
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The priority value of this redundancy
|
|
entry. This value is same as the
|
|
value configured in 'clrRedPriority'
|
|
for a redundancy group."
|
|
::= { clrRedundancyInfoEntry 1 }
|
|
|
|
clrRedundancyState OBJECT-TYPE
|
|
SYNTAX CiscoL4L7RedState
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The current redundancy state."
|
|
::= { clrRedundancyInfoEntry 2 }
|
|
|
|
clrRedundancyStateChangeTime OBJECT-TYPE
|
|
SYNTAX TimeStamp
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The time of the last change in the current
|
|
redundancy state."
|
|
::= { clrRedundancyInfoEntry 3 }
|
|
|
|
clrRedundancyIpAddressType OBJECT-TYPE
|
|
SYNTAX InetAddressType
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The type of internet address by which
|
|
this redundant device reachable."
|
|
::= { clrRedundancyInfoEntry 4 }
|
|
|
|
clrRedundancyIpAddress OBJECT-TYPE
|
|
SYNTAX InetAddress
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object identifies the Internet address by which
|
|
this redundant device is reachable. The type of this
|
|
address is determined by the value of the
|
|
clrRedundancyIpAddressType object."
|
|
::= { clrRedundancyInfoEntry 5 }
|
|
|
|
|
|
|
|
clrLBStatsTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrLBStatsEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table contains the load balance statistics
|
|
related to a redundancy group."
|
|
::= { clrStats 1 }
|
|
|
|
clrLBStatsEntry OBJECT-TYPE
|
|
SYNTAX ClrLBStatsEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Each entry represents the load balance statistics
|
|
applicable for a redundancy group. The entPhysicalIndex
|
|
specifies the entry in entPhysicalTable.
|
|
The entries will get created in this table
|
|
by way of adding entries in clrRedundancyConfigTable.
|
|
The entries will be deleted from this table
|
|
by way of removing entries in clrRedundancyConfigTable."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrRedGroupId
|
|
}
|
|
::= { clrLBStatsTable 1 }
|
|
|
|
ClrLBStatsEntry ::= SEQUENCE {
|
|
clrLBStatsSharedStickyEntries Counter64,
|
|
clrLBStatsSentPackets Counter64,
|
|
clrLBStatsSendFailures Counter64,
|
|
clrLBStatsDroppedEntries Counter64,
|
|
clrLBStatsReceivedPackets Counter64,
|
|
clrLBStatsReceiveFailures Counter64
|
|
}
|
|
|
|
clrLBStatsSharedStickyEntries OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object indicates the number of sticky entries that the
|
|
local device sent to the peer. Sticky entries is a LB
|
|
configuration which allows multiple connections from the same
|
|
client to be sent to the same server. Stickiness can be
|
|
configured based on source IP address, HTTP cookies, SSL session
|
|
ID ( for SSL traffic only ) , etc."
|
|
::= { clrLBStatsEntry 1 }
|
|
|
|
clrLBStatsSentPackets OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of valid packets that the local
|
|
device sent to the peer."
|
|
::= { clrLBStatsEntry 2 }
|
|
|
|
clrLBStatsSendFailures OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of packets that the local
|
|
device attempted to send to the peer, but failed."
|
|
::= { clrLBStatsEntry 3 }
|
|
|
|
clrLBStatsDroppedEntries OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of sticky entries that the peer
|
|
sent to the local device, but the local device discarded them."
|
|
::= { clrLBStatsEntry 4 }
|
|
|
|
clrLBStatsReceivedPackets OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of valid packets that the local
|
|
device received from the peer."
|
|
::= { clrLBStatsEntry 5 }
|
|
|
|
clrLBStatsReceiveFailures OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of packets that the peer sent
|
|
to the local device, but the local device failed to receive
|
|
them."
|
|
::= { clrLBStatsEntry 6 }
|
|
|
|
|
|
|
|
clrHAStatsTable OBJECT-TYPE
|
|
SYNTAX SEQUENCE OF ClrHAStatsEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This table contains the statistics related to
|
|
a redundant peer."
|
|
::= { clrStats 2 }
|
|
|
|
clrHAStatsEntry OBJECT-TYPE
|
|
SYNTAX ClrHAStatsEntry
|
|
MAX-ACCESS not-accessible
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Each entry represents the statistics
|
|
applicable for a redundant peer.
|
|
The entPhysicalIndex specifies the
|
|
entry in entPhysicalTable .
|
|
The entries will get created in this table
|
|
by way of adding entries in clrPeerConfigTable.
|
|
The entries will be deleted from this table
|
|
by way of removing entries in clrPeerConfigTable."
|
|
INDEX {
|
|
entPhysicalIndex,
|
|
clrPeerId
|
|
}
|
|
::= { clrHAStatsTable 1 }
|
|
|
|
ClrHAStatsEntry ::= SEQUENCE {
|
|
clrHAStatsTxHeartBeatMsgs Counter64,
|
|
clrHAStatsRxHeartBeatMsgs Counter64,
|
|
clrHAStatsMissedHeartBeatMsgs Counter64,
|
|
clrHAStatsRxUniDirectionalHeartBeatMsgs Counter64,
|
|
clrHAStatsHeartBeatTimeoutMismatches Counter64,
|
|
clrHAStatsPeerUpEvents Counter64,
|
|
clrHAStatsPeerDownEvents Counter64
|
|
}
|
|
|
|
clrHAStatsTxHeartBeatMsgs OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object refers to the number of heart beat messages sent
|
|
to the peer."
|
|
::= { clrHAStatsEntry 1 }
|
|
|
|
clrHAStatsRxHeartBeatMsgs OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object refers to the number of heart beat messages
|
|
received from the peer."
|
|
::= { clrHAStatsEntry 2 }
|
|
|
|
clrHAStatsMissedHeartBeatMsgs OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object refers to the number of missed heart
|
|
beat messages."
|
|
::= { clrHAStatsEntry 3 }
|
|
|
|
clrHAStatsRxUniDirectionalHeartBeatMsgs OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object indicates that the heartbeat messages from a peer
|
|
is unidirectional. That is, the peer cannot receive ( only send
|
|
) heartbeats."
|
|
::= { clrHAStatsEntry 4 }
|
|
|
|
clrHAStatsHeartBeatTimeoutMismatches OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"Each HB packet contains the configured interval in the packet.
|
|
When a peer receives a HB packet, it checks to see if the
|
|
interval in the HB packet matches the interval configured
|
|
locally. This object indicates the number of HB that the local
|
|
device received from the remote peer with a mismatched HB
|
|
interval."
|
|
::= { clrHAStatsEntry 5 }
|
|
|
|
clrHAStatsPeerUpEvents OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of peer up messages that the
|
|
local device sent to the remote peer."
|
|
::= { clrHAStatsEntry 6 }
|
|
|
|
clrHAStatsPeerDownEvents OBJECT-TYPE
|
|
SYNTAX Counter64
|
|
MAX-ACCESS read-only
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object contains the number of peer down messages that the
|
|
local device sent to the remote peer."
|
|
::= { clrHAStatsEntry 7 }
|
|
|
|
|
|
|
|
clrStateChangeNotifEnabled OBJECT-TYPE
|
|
SYNTAX TruthValue
|
|
MAX-ACCESS read-write
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This object controls the generation of
|
|
clrRedundancyStateChange notification.
|
|
'true' : Indicates that clrRedundancyStateChange
|
|
notification is to be generated when the state
|
|
changes. That is, notification generation
|
|
is enabled.
|
|
'false' : Indicates that clrRedundancyStateChange
|
|
notification generation is disabled."
|
|
DEFVAL { false }
|
|
::= { clrNotifObjects 1 }
|
|
|
|
clrRedundancyStateChange NOTIFICATION-TYPE
|
|
OBJECTS {
|
|
clrRedState,
|
|
clrRedStateChangeTime,
|
|
clrRedPeerId
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The notification generated when the redundancy state
|
|
is changed."
|
|
::= { ciscoLmRedundancyMIBNotifs 1 }
|
|
-- Conformance Information
|
|
|
|
ciscoLmRedundancyMIBCompliances OBJECT IDENTIFIER
|
|
::= { ciscoLmRedundancyMIBConformance 1 }
|
|
|
|
ciscoLmRedundancyMIBGroups OBJECT IDENTIFIER
|
|
::= { ciscoLmRedundancyMIBConformance 2 }
|
|
|
|
|
|
-- Compliance
|
|
|
|
ciscoLmRedundancyMIBCompliance MODULE-COMPLIANCE
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The compliance statement for entities which implement
|
|
the L4L7 Switch Redundancy."
|
|
MODULE -- this module
|
|
MANDATORY-GROUPS {
|
|
clrPeerConfigGroup,
|
|
clrRedConfigGroup,
|
|
clrRedundancyStatsGroup
|
|
}
|
|
::= { ciscoLmRedundancyMIBCompliances 1 }
|
|
|
|
-- Units of Conformance
|
|
|
|
clrPeerConfigGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
clrPeerInterface,
|
|
clrPeerBackupInterface,
|
|
clrPeerHeartBeatTime,
|
|
clrPeerHeartBeatCount,
|
|
clrPeerOperStatus,
|
|
clrPeerIpAddressType,
|
|
clrPeerIpAddress,
|
|
clrPeerStorageType,
|
|
clrPeerRowStatus,
|
|
clrPeerSoftwareCompatibilty,
|
|
clrPeerLicenseCompatibility,
|
|
clrPeerRedGroups
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This group contains the peer configuration objects."
|
|
::= { ciscoLmRedundancyMIBGroups 1 }
|
|
|
|
clrRedConfigGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
clrRedPeerId,
|
|
clrRedPriority,
|
|
clrRedPreempt,
|
|
clrRedFailOverTime,
|
|
clrRedState,
|
|
clrRedStateChangeTime,
|
|
clrRedStorageType,
|
|
clrRedRowStatus,
|
|
clrRedContext
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This group contains the redundancy configuration objects."
|
|
::= { ciscoLmRedundancyMIBGroups 2 }
|
|
|
|
clrRedInfoGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
clrRedundancyPriority,
|
|
clrRedundancyState,
|
|
clrRedundancyStateChangeTime,
|
|
clrRedundancyIpAddressType,
|
|
clrRedundancyIpAddress
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This group contains the redundancy information objects."
|
|
::= { ciscoLmRedundancyMIBGroups 3 }
|
|
|
|
cslbxNotifControlGroup OBJECT-GROUP
|
|
OBJECTS { clrStateChangeNotifEnabled }
|
|
STATUS current
|
|
DESCRIPTION
|
|
"The collection of objects to control the
|
|
notifications for state changed in a L4
|
|
redundancy configuration."
|
|
::= { ciscoLmRedundancyMIBGroups 4 }
|
|
|
|
cslbxNotifGroup NOTIFICATION-GROUP
|
|
NOTIFICATIONS { clrRedundancyStateChange }
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This group contains the notifications related to
|
|
redundancy."
|
|
::= { ciscoLmRedundancyMIBGroups 5 }
|
|
|
|
clrRedundancyStatsGroup OBJECT-GROUP
|
|
OBJECTS {
|
|
clrHAStatsTxHeartBeatMsgs,
|
|
clrHAStatsRxHeartBeatMsgs,
|
|
clrHAStatsMissedHeartBeatMsgs,
|
|
clrHAStatsRxUniDirectionalHeartBeatMsgs,
|
|
clrHAStatsHeartBeatTimeoutMismatches,
|
|
clrHAStatsPeerUpEvents,
|
|
clrHAStatsPeerDownEvents,
|
|
clrLBStatsSharedStickyEntries,
|
|
clrLBStatsSentPackets,
|
|
clrLBStatsSendFailures,
|
|
clrLBStatsDroppedEntries,
|
|
clrLBStatsReceivedPackets,
|
|
clrLBStatsReceiveFailures
|
|
}
|
|
STATUS current
|
|
DESCRIPTION
|
|
"This group contains objects related to redundant peer and
|
|
load balacing statistics."
|
|
::= { ciscoLmRedundancyMIBGroups 6 }
|
|
|
|
END
|