The Managed Object Aggregation MIB
RFC 4498
This RFC was published on the Independent Submission stream.
This RFC is not endorsed by the IETF and has no formal standing in the
IETF standards process.
| Document | Type |
RFC
- Experimental
(May 2006)
Was
draft-glenn-mo-aggr-mib
(gen)
|
|
|---|---|---|---|
| Author | Dr. Glenn Mansfield Keeni | ||
| Last updated | 2015-10-14 | ||
| RFC stream | Independent Submission | ||
| Formats | |||
| IESG | Responsible AD | Dan Romascanu | |
| Send notices to | (None) |
RFC 4498
Network Working Group G. Keeni
Request for Comments: 4498 Cyber Solutions Inc.
Category: Experimental May 2006
The Managed Object Aggregation MIB
Status of This Memo
This memo defines an Experimental Protocol for the Internet
community. It does not specify an Internet standard of any kind.
Discussion and suggestions for improvement are requested.
Distribution of this memo is unlimited.
Copyright Notice
Copyright (C) The Internet Society (2006).
IESG Note
The content of this RFC was at one time considered by the IETF, and
therefore it may resemble a current IETF work in progress or a
published IETF work. This RFC is not a candidate for any level of
Internet Standard. The IETF disclaims any knowledge of the fitness
of this RFC for any purpose and in particular notes that the decision
to publish is not based on IETF review for such things as security,
congestion control, or inappropriate interaction with deployed
protocols. The RFC Editor has chosen to publish this document at its
discretion. Readers of this RFC should exercise caution in
evaluating its value for implementation and deployment. See RFC 3932
for more information.
Abstract
This memo defines a portion of the Management Information Base (MIB),
the Aggregation MIB modules, for use with network management
protocols in the Internet community. In particular, the Aggregation
MIB modules will be used to configure a network management agent to
aggregate the values of a user-specified set of Managed Object
instances and to service queries related to the aggregated Managed
Object instances.
Keeni Experimental [Page 1]
RFC 4498 The Managed Object Aggregation MIB May 2006
Table of Contents
1. The Internet-Standard Management Framework ......................2
2. Background ......................................................2
3. MO Aggregation: The Concept .....................................3
4. The Requirements for Managed Object Aggregation .................6
5. MIB Design ......................................................6
6. The Aggregation MIB Modules .....................................7
7. Security Considerations ........................................25
8. IANA Considerations ............................................27
9. References .....................................................27
9.1. Normative References ......................................27
9.2. Informative References ....................................27
10. Acknowledgements ..............................................28
1. The Internet-Standard Management Framework
For a detailed overview of the documents that describe the current
Internet-Standard Management Framework, please refer to section 7 of
RFC 3410 [RFC3410].
Managed objects are accessed via a virtual information store, termed
the Management Information Base or MIB. MIB objects are generally
accessed through the Simple Network Management Protocol (SNMP).
Objects in the MIB are defined using the mechanisms defined in the
Structure of Management Information (SMI). This memo specifies a MIB
module that is compliant to the SMIv2, which is described in STD 58,
RFC 2578 [RFC2578], STD 58, RFC 2579 [RFC2579] and STD 58, RFC 2580
[RFC2580].
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in BCP 14, RFC 2119
[RFC2119].
2. Background
For the purpose of management, it is necessary to access Managed
Objects (MOs). The SNMP framework provides a mechanism for naming
and describing managed objects. These objects are accessed via a
virtual information store termed a Management Information Base (MIB).
MIBs have been defined by equipment, protocol, and application
developers to provide management access to the managed entities. We
will call the MOs defined in these MIBs simple MOs (SMO). Management
applications will access one or more instances of these SMOs, one or
more times, to monitor the target entity.
Keeni Experimental [Page 2]
RFC 4498 The Managed Object Aggregation MIB May 2006
There is a cost associated with accessing MOs. The cost is the
network bandwidth and the packet header processing overhead at the
command generator (manager) and the command responder (agent). This
cost constrains the number of MO instances that can be polled and the
interval at which polling can be carried out.
The overhead reduction can be carried out by reducing the number of
query-response packets. This will reduce the packet processing
overhead, and to some extent, the bandwidth.
The payloads in a typical SNMP "get" packet and the corresponding
response are as shown in Figure 1. In this example, polling is
carried out for 'n' Managed Object instances OID1, OID2, ..., OIDn.
It is obvious that a substantial amount of the payload in an SNMP
packet consists of the OIDs.
3. MO Aggregation: The Concept
In this document, a mechanism of MO aggregation for payload
compression is defined. The idea is simple: we introduce the concept
of an Aggregate MO (AgMO). An AgMO is just another MO as far as the
SNMP protocol is concerned. No new protocol operations will be
required to handle these MOs. As in the case of any other MO, it
requires additional instrumentation at the command responder (agent)
and at the (command generator) manager. In this mechanism, the user
defines an Aggregate MO (AgMO) corresponding to one or more
(predefined) MO instances. Semantically, the value of an AgMO
instance will be equivalent to the concatenation of the values of the
corresponding MO instances. The order of the concatenation will be
determined by the order in which the MO instances are specified in
the AgMO definition. With the definitions done, the user can, as and
when the necessity arises, do an SNMP 'get' on instances of the AgMO
to fetch the value of the constituent MO instances. There is
substantial savings on bandwidth, as only one instance object
identifier is carried in the request and the response. In the normal
case, instance object identifiers for each of the constituent MO
instances would be carried in the requests and the responses. This
is the basic concept of Aggregate Managed Objects. For every AgMO,
an ErrorStatus Managed Object is defined. This MO indicates errors,
if any, that have been encountered while fetching the values of the
constituent MO instances. The error indication is comprised of the
index of the MO instance and the corresponding error. If there are
no errors, the ErrorStatus Managed Object instance will have a null
value. This is the basic concept of Aggregate Managed Objects.
Keeni Experimental [Page 3]
RFC 4498 The Managed Object Aggregation MIB May 2006
The concepts are explained in Figure 2. An aggregate managed object,
AgMOx, has been defined for the MO instances MOI1, ... MOIn. The
value of an instance of AgMOx will be a concatenation of the values
of MOI1, ... MOIn, in that order.
Polling for MO Instances [MOI1, MOI2, ... MOIn]:
+--------+------+-------+... -+------+------+
Query: |Get req | MOI1 | NULL | | MOIn | NULL |
+--------+------+-------+... -+------+------+
+--------+------+-------+... -+------+------+
Response: |Get resp| MOI1 | Val1 | | MOIn | Valn |
+--------+------+-------+... -+------+------+
Figure 1. Polling for MO instances
Polling for an instance (AgMOIx) of an aggregate MO (AgMOx):
AgMOx = aggr{AgMOI1, AgMOI2, ......AgMOIn}
+--------+--------+-------+
Query: |Get req | AgMOIx | NULL |
+--------+--------+-------+
+--------+--------+------------------------+
Response: |Get resp| AgMOIx | Val1,Val2,...,Valn |
+--------+--------+------------------------+
Figure 2. MO aggregation
As a further refinement of the AgMO, we introduce the Time-Based
Aggregated Managed Object (TAgMO). The TAgMO is an MO that
represents the values of a user-specified MO instance sampled at
user-specified intervals for a user-specified number of times. In
this case, the user defines a TAgMO by specifying the MO instance
that needs to be sampled, the sampling interval, and the desired
number of samples that will be included in one TAgMO. The value of a
TAgMO instance will include the timestamp (sysUpTime) at which the
first sample was taken. The start time is not specified when the
TAgMO is defined. Implementations may choose to align the start time
with the appropriate time boundaries (e.g., seconds, minutes, hours).
With the definitions, the user can do an SNMP "get" on an instance of
the TAgMO to fetch the values of the constituent MO instance sampled
at the specified intervals. This is the concept of Time-Based
aggregation.
Keeni Experimental [Page 4]
RFC 4498 The Managed Object Aggregation MIB May 2006
Polling for 'n' samples of an MO Instance [MOI] at an interval 'i':
Query Time Response
===== ==== ========
+--------+-----+-----------+
|Get req | MOI | NULL | t
+--------+-----+-----------+ : +--------+-----+--------------+
: |Get resp| MOI | Val(t) |
: +--------+-----+--------------+
+--------+-----+-----------+ t+i
|Get req | MOI | NULL | :
+--------+-----+-----------+ : +--------+-----+--------------+
: |Get resp| MOI | Val(t+i) |
X +--------+-----+--------------+
X
:
+--------+-----+-----------+ t+(n-1)i
|Get req | MOI | NULL | :
+--------+-----+-----------+ : +--------+-----+--------------+
: |Get resp| MOI | Val(t+(n-1)i)|
+--------+-----+--------------+
Figure 3. Periodic polling for samples of an MO instance
Polling for an instance (TAgMOIx) of a Time-Based aggregate MO
(TAgMOx):
TAgMOx = aggr{'n' polled samples of an instance (MOI) of MO
at intervals = 'i' microseconds}
+--------+---------+-------+
Query: |Get req | TAgMOIx | NULL |
+--------+---------+-------+
+--------+---------+--------------------------------------+
Response: |Get resp| TAgMOIx | t,Val(t),Val(t+i),.,Val(t + (n-1)*i) |
+--------+---------+--------------------------------------+
Figure 4. Time-Based aggregation
The TAgMO instance is a "bucket" of data representing the value of
the corresponding MO instance sampled at 'i' microsecond intervals,
'n' times (i.e., over a 'n' X 'i' microsecond window). The TAgMO
instance value gets updated at 'n' X 'i' microsecond intervals.
Keeni Experimental [Page 5]
RFC 4498 The Managed Object Aggregation MIB May 2006
4. The Requirements for Managed Object Aggregation
The general requirements of managed object aggregation are as
follows:
o It should lead to fewer packets.
o It should lead to less bandwidth consumption.
o It should not lead to loss of information.
In the case of Time-Based aggregation, there will be a delay involved
in getting the actual data. The minimum delay in this case will be
the duration of the aggregation.
The manager application is expected to configure AgMOs (Aggregate
MOs) and TAgMOs (Time-Based Aggregate MOs) with care so that the
response size is not too large. In case the resultant response size
is larger than the maximum acceptable message size of the originator
or larger than the local maximum message size, then the error-status
field will be set to "tooBig".
Note that an aggregate MO can be defined only when all the
constituent MO instances of interest are known. This scheme cannot
be employed if a manager/application does not know the specific MO
instances (of interest) that are serviced by the management target.
In such cases, the application may "discover" the MO instances of
interest by some means, e.g., by "walking" through the MIB tree on
the agent. According to the results of the "walk", the application
can define an appropriate aggregate MO that will serve the purpose.
Considering the cost involved in this exercise, this method is
recommended only if the aggregate MO will be used repeatedly, so that
the benefits of aggregation outweigh the costs of configuration.
5. MIB Design
The basic principle has been to keep the MIB as simple as possible
and at the same time to make it flexible enough that a large number
of users and applications can use the MIB to configure aggregate MOs
conveniently.
Two separate MIB modules have been defined. The AggrMIB supports the
aggregation of independent MO instances, while TAggrMIB supports the
aggregation of several samples of the same MO instance. Both of
these MIB modules use the textual conventions defined in RMON-MIB
[RFC2819] and SNMP-FRAMEWORK-MIB [RFC3411].
Keeni Experimental [Page 6]
RFC 4498 The Managed Object Aggregation MIB May 2006
The AggrMIB is comprised of three tables, described below.
- The aggrCtlTable controls the aggregation process. Each row in
this table defines the attributes of the aggregate object defined
in the aggrMOTable.
- The aggrMOTable defines the primary MO-based aggregation, i.e.,
the MOs that will be aggregated.
- The aggrDataTable contains the details of the aggregated object.
The TAggrMIB is comprised of two tables described below.
- The tAggrCtlTable controls the aggregation process. Each row in
this table defines the attributes of the aggregate object defined
in the aggrMOTable.
- The tAggrDataTable contains the details of the aggregated object.
6. The Aggregation MIB Modules
AGGREGATE-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, experimental, Unsigned32,
OBJECT-TYPE, Opaque
FROM SNMPv2-SMI
OwnerString
FROM RMON-MIB
RowStatus, StorageType, TEXTUAL-CONVENTION
FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP
FROM SNMPv2-CONF
SnmpAdminString
FROM SNMP-FRAMEWORK-MIB;
aggrMIB MODULE-IDENTITY
LAST-UPDATED "200604270000Z" -- 27th April, 2006
ORGANIZATION "Cyber Solutions Inc. NetMan Working Group"
CONTACT-INFO
" Glenn Mansfield Keeni
Postal: Cyber Solutions Inc.
6-6-3, Minami Yoshinari
Aoba-ku, Sendai, Japan 989-3204.
Tel: +81-22-303-4012
Fax: +81-22-303-4015
E-mail: glenn@cysols.com
Support Group E-mail: mibsupport@cysols.com"
Keeni Experimental [Page 7]
RFC 4498 The Managed Object Aggregation MIB May 2006
DESCRIPTION
"The MIB for servicing aggregate objects.
Copyright (C) The Internet Society (2006). This
version of this MIB module is part of RFC 4498;
see the RFC itself for full legal notices.
"
REVISION "200604270000Z" -- 27th April, 2006
DESCRIPTION "Initial version, published as RFC 4498."
::= { experimental 123 }
AggrMOErrorStatus ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the error status of the
constituent MO instances. The error status for a
constituent MO instance is given in terms of two elements:
o The moIndex, which indicates the position of the MO
instance (starting at 1) in the value of the aggregated
MO instance.
o The moError, which indicates the error that was
encountered in fetching that MO instance.
The syntax in ASN.1 Notation will be
ErrorStatus :: = SEQUENCE {
moIndex Integer32,
moError SnmpPduErrorStatus
}
AggrMOErrorStatus ::= SEQUENCE OF {
ErrorStatus
}
Note1: The command responder will supply values for all
constituent MO instances, in the same order in
which the MO instances are specified for the AgMO.
If an error is encountered for an MO instance, then
the corresponding value will have an ASN.1 value NULL,
and an error will be flagged in the corresponding
AggrMOErrorStatus object.
Only MOs for which errors have been encountered will
have their corresponding moIndex and moError values
set.
Note2: The error code for the component MO instances will be
in accordance with the SnmpPduErrorStatus TC defined
in the DISMAN-SCHEDULE-MIB [RFC3231].
Note3: The command generator will need to know
constituent MO instances and their order to correctly
interpret AggrMOErrorStatus.
"
SYNTAX Opaque (SIZE (0..1024))
Keeni Experimental [Page 8]
RFC 4498 The Managed Object Aggregation MIB May 2006
AggrMOValue ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the aggregate
MOs. It will have a format dependent on the constituent
MOs, a sequence of values. The syntax in ASN.1 Notation will
be
MOValue :: = SEQUENCE {
value ObjectSyntax
}
where 'value' is the value of a constituent MO instance.
AggrMOValue :: = SEQUENCE OF {
MOValue
}
Note: The command generator will need to know the
constituent MO instances and their order to
correctly interpret AggrMOValue."
SYNTAX Opaque (SIZE (0..1024))
AggrMOCompressedValue ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the compressed
aggregate MOs."
SYNTAX OCTET STRING (SIZE (0..1024))
--
-- The aggregation control table
-- There will be a row for each aggregate MO
--
aggrCtlTable OBJECT-TYPE
SYNTAX SEQUENCE OF AggrCtlEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A table that controls the aggregation of the MOs."
::= {aggrMIB 1}
aggrCtlEntry OBJECT-TYPE
SYNTAX AggrCtlEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A row of the control table that defines one aggregated
MO.
Keeni Experimental [Page 9]
RFC 4498 The Managed Object Aggregation MIB May 2006
Entries in this table are required to survive a reboot
of the managed entity depending on the value of the
corresponding aggrCtlEntryStorageType instance.
"
INDEX {aggrCtlEntryID }
::= {aggrCtlTable 1 }
AggrCtlEntry ::= SEQUENCE {
aggrCtlEntryID
SnmpAdminString,
aggrCtlMOIndex
Unsigned32,
aggrCtlMODescr
SnmpAdminString,
aggrCtlCompressionAlgorithm
INTEGER,
aggrCtlEntryOwner
OwnerString,
aggrCtlEntryStorageType
StorageType,
aggrCtlEntryStatus
RowStatus
}
aggrCtlEntryID OBJECT-TYPE
SYNTAX SnmpAdminString (SIZE(1..32))
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A locally unique, administratively assigned name
for this aggregated MO. It is used as an index to
uniquely identify this row in the table."
::= { aggrCtlEntry 1 }
aggrCtlMOIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..2147483647)
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"A pointer to a group of MOs identified by aggrMOEntryID
in the aggrMOTable. This is the group of MOs that will
be aggregated."
::= { aggrCtlEntry 2 }
aggrCtlMODescr OBJECT-TYPE
SYNTAX SnmpAdminString (SIZE(0..64))
MAX-ACCESS read-create
STATUS current
Keeni Experimental [Page 10]
RFC 4498 The Managed Object Aggregation MIB May 2006
DESCRIPTION
"A textual description of the object that is
being aggregated."
::= {aggrCtlEntry 3}
-- only one compression algorithm is defined as of now.
aggrCtlCompressionAlgorithm OBJECT-TYPE
SYNTAX INTEGER {
none (1),
deflate (2)
}
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The compression algorithm that will be used by
the agent to compress the value of the aggregated
object.
The deflate algorithm and corresponding data format
specification is described in RFC 1951. It is
compatible with the widely used gzip utility.
"
REFERENCE
"RFC1951 : DEFLATE Compressed Data Format Specification
version 1.3
"
DEFVAL { none }
::= {aggrCtlEntry 4}
aggrCtlEntryOwner OBJECT-TYPE
SYNTAX OwnerString
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The entity that created this entry."
::= {aggrCtlEntry 5}
aggrCtlEntryStorageType OBJECT-TYPE
SYNTAX StorageType
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"This object defines whether the parameters defined in
this row are kept in volatile storage and lost upon
reboot or backed up by non-volatile (permanent)
storage.
Conceptual rows having the value 'permanent' need not
allow write-access to any columnar objects in the row.
Keeni Experimental [Page 11]
RFC 4498 The Managed Object Aggregation MIB May 2006
"
::= {aggrCtlEntry 6}
aggrCtlEntryStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The row status variable, used according to row
installation and removal conventions.
Objects in a row can be modified only when the value of
this object in the corresponding conceptual row is not
'active'.
Thus, to modify one or more of the objects in this
conceptual row,
a. change the row status to 'notInService',
b. change the values of the row, and
c. change the row status to 'active'.
The aggrCtlEntryStatus may be changed to 'active' if
all the MOs in the conceptual row have been assigned
valid values.
"
::= {aggrCtlEntry 7}
--
-- The Table of primary(simple) MOs
--
aggrMOTable OBJECT-TYPE
SYNTAX SEQUENCE OF AggrMOEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table of primary(simple) MOs that will be aggregated.
Each row in this table represents a MO that will be
aggregated. The aggrMOEntryID index is used to identify
the group of MOs that will be aggregated. The
aggrMOIndex instance in the corresponding row of the
aggrCtlTable will have a value equal to the value of
aggrMOEntryID. The aggrMOEntryMOID index is used to
identify an MO in the group.
"
::= {aggrMIB 2}
aggrMOEntry OBJECT-TYPE
SYNTAX AggrMOEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
Keeni Experimental [Page 12]
RFC 4498 The Managed Object Aggregation MIB May 2006
"A row of the table that specifies one MO.
Entries in this table are required to survive a reboot
of the managed entity depending on the value of the
corresponding aggrMOEntryStorageType instance.
"
INDEX { aggrMOEntryID, aggrMOEntryMOID }
::= {aggrMOTable 1 }
AggrMOEntry ::= SEQUENCE {
aggrMOEntryID
Unsigned32,
aggrMOEntryMOID
Unsigned32,
aggrMOInstance
OBJECT IDENTIFIER,
aggrMODescr
SnmpAdminString,
aggrMOEntryStorageType
StorageType,
aggrMOEntryStatus
RowStatus
}
aggrMOEntryID OBJECT-TYPE
SYNTAX Unsigned32 (1..2147483647)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An index uniquely identifying a group of MOs
that will be aggregated."
::= { aggrMOEntry 1 }
aggrMOEntryMOID OBJECT-TYPE
SYNTAX Unsigned32 (1..65535)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An index to uniquely identify an MO instance in the
group of MO instances that will be aggregated."
::= { aggrMOEntry 2 }
aggrMOInstance OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The OID of the MO instance, the value of which will
be sampled by the agent."
Keeni Experimental [Page 13]
RFC 4498 The Managed Object Aggregation MIB May 2006
::= { aggrMOEntry 3 }
aggrMODescr OBJECT-TYPE
SYNTAX SnmpAdminString (SIZE(0..64))
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"A textual description of the object that will
be aggregated."
::= {aggrMOEntry 4}
aggrMOEntryStorageType OBJECT-TYPE
SYNTAX StorageType
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"This object defines whether the parameters defined in
this row are kept in volatile storage and lost upon
reboot or backed up by non-volatile (permanent)
storage.
Conceptual rows having the value 'permanent' need not
allow write-access to any columnar objects in the row.
"
::= {aggrMOEntry 5}
aggrMOEntryStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The row status variable, used according to row
installation and removal conventions.
Objects in a row can be modified only when the value of
this object in the corresponding conceptual row is not
'active'.
Thus, to modify one or more of the objects in this
conceptual row,
a. change the row status to 'notInService',
b. change the values of the row, and
c. change the row status to 'active'.
The aggrMOEntryStatus may be changed to 'active' iff
all the MOs in the conceptual row have been assigned
valid values.
"
::= {aggrMOEntry 6}
--
-- aggrDataTable: The Table of Data. Each row represents a Data
Keeni Experimental [Page 14]
RFC 4498 The Managed Object Aggregation MIB May 2006
-- set. aggrCtlEntryID is the key to the table.
-- It is used to identify instances of the
-- aggregated MO that are present in the table.
--
aggrDataTable OBJECT-TYPE
SYNTAX SEQUENCE OF AggrDataEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Each row of this table contains information
about an aggregateMO indexed by aggrCtlEntryID."
::= {aggrMIB 3}
aggrDataEntry OBJECT-TYPE
SYNTAX AggrDataEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Entry containing information pertaining to
an aggregate MO."
INDEX {aggrCtlEntryID}
::= {aggrDataTable 1 }
AggrDataEntry ::= SEQUENCE {
aggrDataRecord
AggrMOValue,
aggrDataRecordCompressed
AggrMOCompressedValue,
aggrDataErrorRecord
AggrMOErrorStatus
}
aggrDataRecord OBJECT-TYPE
SYNTAX AggrMOValue
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The snapshot value of the aggregated MO.
Note that the access privileges to this object will be
governed by the access privileges of the component
objects. Thus, an entity attempting to access an
instance of this MO MUST have access rights to all the
component instance objects and this MO instance.
"
::= { aggrDataEntry 1}
aggrDataRecordCompressed OBJECT-TYPE
SYNTAX AggrMOCompressedValue
Keeni Experimental [Page 15]
RFC 4498 The Managed Object Aggregation MIB May 2006
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The compressed value of the aggregated MO.
The compression algorithm will depend on the
aggrCtlCompressionAlgorithm given in the corresponding
aggrCtlEntry. If the value of the corresponding
aggrCtlCompressionAlgorithm is (1) 'none', then the value
of all instances of this object will be a string of zero
length.
Note that the access privileges to this object will be
governed by the access privileges of the component
objects. Thus, an entity attempting to access an instance
of this MO MUST have access rights to all the component
instance objects and this MO instance.
"
::= { aggrDataEntry 2}
aggrDataErrorRecord OBJECT-TYPE
SYNTAX AggrMOErrorStatus
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The error status corresponding to the MO instances
aggregated in aggrDataRecord (and
aggrDataRecordCompressed)."
::= { aggrDataEntry 3}
-- Conformance information
aggrConformance OBJECT IDENTIFIER ::= { aggrMIB 4 }
aggrGroups OBJECT IDENTIFIER ::= { aggrConformance 1 }
aggrCompliances OBJECT IDENTIFIER ::= { aggrConformance 2 }
-- Compliance statements
aggrMibCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"The compliance statement for SNMP entities
that implement the AGGREGATE-MIB."
MODULE -- this module
MANDATORY-GROUPS { aggrMibBasicGroup }
::= { aggrCompliances 1 }
-- Units of conformance
aggrMibBasicGroup OBJECT-GROUP
OBJECTS {
aggrCtlMOIndex,
aggrCtlMODescr,
Keeni Experimental [Page 16]
RFC 4498 The Managed Object Aggregation MIB May 2006
aggrCtlCompressionAlgorithm,
aggrCtlEntryOwner,
aggrCtlEntryStorageType,
aggrCtlEntryStatus,
aggrMOInstance,
aggrMODescr,
aggrMOEntryStorageType,
aggrMOEntryStatus,
aggrDataRecord,
aggrDataRecordCompressed,
aggrDataErrorRecord
}
STATUS current
DESCRIPTION
"A collection of objects for aggregation of MOs."
::= { aggrGroups 1 }
END
TIME-AGGREGATE-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, experimental,
OBJECT-TYPE, Opaque, Integer32
FROM SNMPv2-SMI
OwnerString
FROM RMON-MIB
RowStatus, StorageType, TEXTUAL-CONVENTION
FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP
FROM SNMPv2-CONF
SnmpAdminString
FROM SNMP-FRAMEWORK-MIB;
tAggrMIB MODULE-IDENTITY
LAST-UPDATED "200604270000Z" -- 27 April 2006
ORGANIZATION "Cyber Solutions Inc. NetMan Working Group"
CONTACT-INFO
" Glenn Mansfield Keeni
Postal: Cyber Solutions Inc.
6-6-3, Minami Yoshinari
Aoba-ku, Sendai, Japan 989-3204.
Tel: +81-22-303-4012
Fax: +81-22-303-4015
E-mail: glenn@cysols.com
Support Group E-mail: mibsupport@cysols.com"
DESCRIPTION
Keeni Experimental [Page 17]
RFC 4498 The Managed Object Aggregation MIB May 2006
"The MIB for servicing Time-Based aggregate
objects.
Copyright (C) The Internet Society (2006). This
version of this MIB module is part of RFC 4498;
see the RFC itself for full legal notices.
"
REVISION "200604270000Z" -- 27th April, 2006
DESCRIPTION "Initial version, published as RFC 4498."
::= { experimental 124 }
TAggrMOErrorStatus ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the error status of the
sampled MO instance. The error status for a sampled MO
instance is given in terms of two elements:
o The moIndex, which indicates the sample number of the MO
instance (starting at 1) in the value of the time-
aggregated MO instance.
o The moError, which indicates the error that was
encountered in sampling that MO instance.
The syntax in ASN.1 Notation will be
ErrorStatus :: = SEQUENCE {
moIndex Integer32,
moError SnmpPduErrorStatus
}
TAggrMOErrorStatus ::= SEQUENCE OF {
ErrorStatus
}
Note1: The command responder will supply values for all
the samples of the MO instance. If an error is
encountered for a sample, then the corresponding
value will have an ASN.1 value NULL, and an error
will be flagged in the corresponding
TAggrMOErrorStatus object.
Only MOs for which errors have been encountered will
the corresponding moIndex and moError values be set.
Note2: The error code for the component MO instances will be
in accordance with the SnmpPduErrorStatus TC defined
in the DISMAN-SCHEDULE-MIB[RFC3231].
"
SYNTAX Opaque (SIZE (0..1024))
TimeAggrMOValue ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the time-aggregated MOs. It
Keeni Experimental [Page 18]
RFC 4498 The Managed Object Aggregation MIB May 2006
will be a sequence of values. The syntax in ASN.1 Notation
will be
MOSampleValue :: = SEQUENCE {
value ObjectSyntax
}
TimeAggrMOValue ::= SEQUENCE OF {
MOSampleValue
}
where the first MOSampleValue, if any, will always be the
timestamp of the first sample in the aggregated object. The
subsequent values are the values of the MO instance sampled
at the specified intervals for the specified number of times.
Note: The command generator will need to know the
constituent MO instance and the sampling interval to
correctly interpret TimeAggrMOValue.
"
SYNTAX Opaque (SIZE (0..1024))
CompressedTimeAggrMOValue ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This data type is used to model the compressed
TAgMOs."
SYNTAX Opaque (SIZE (0..1024))
--
-- The Time-Based aggregation control table
--
tAggrCtlTable OBJECT-TYPE
SYNTAX SEQUENCE OF TAggrCtlEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The Time-Based aggregation control table. It controls
the aggregation of the samples of MO instances. There
will be a row for each TAgMO.
"
::= {tAggrMIB 1}
tAggrCtlEntry OBJECT-TYPE
SYNTAX TAggrCtlEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A row of the control table that defines one Time-Based
aggregate MO (TAgMO)."
INDEX {tAggrCtlEntryID }
::= {tAggrCtlTable 1 }
Keeni Experimental [Page 19]
RFC 4498 The Managed Object Aggregation MIB May 2006
TAggrCtlEntry ::= SEQUENCE {
tAggrCtlEntryID
SnmpAdminString,
tAggrCtlMOInstance
OBJECT IDENTIFIER,
tAggrCtlAgMODescr
SnmpAdminString,
tAggrCtlInterval
Integer32,
tAggrCtlSamples
Integer32,
tAggrCtlCompressionAlgorithm
INTEGER,
tAggrCtlEntryOwner
OwnerString,
tAggrCtlEntryStorageType
StorageType,
tAggrCtlEntryStatus
RowStatus
}
tAggrCtlEntryID OBJECT-TYPE
SYNTAX SnmpAdminString (SIZE(1..32))
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A locally unique, administratively assigned name
for this aggregated MO. It is used as an index to
uniquely identify this row in the table."
::= { tAggrCtlEntry 1 }
tAggrCtlMOInstance OBJECT-TYPE
SYNTAX OBJECT IDENTIFIER
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The sampled values of this MO instance will be
aggregated by the TAgMO.
"
::= { tAggrCtlEntry 2 }
tAggrCtlAgMODescr OBJECT-TYPE
SYNTAX SnmpAdminString (SIZE(0..64))
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"A textual description of the aggregate object."
::= {tAggrCtlEntry 3}
Keeni Experimental [Page 20]
RFC 4498 The Managed Object Aggregation MIB May 2006
tAggrCtlInterval OBJECT-TYPE
SYNTAX Integer32
UNITS "micro seconds"
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The interval, in microseconds, at which the MO instance
pointed at by tAggrInstance will be sampled for
Time-Based aggregation.
"
::= {tAggrCtlEntry 4}
tAggrCtlSamples OBJECT-TYPE
SYNTAX Integer32
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The number of times at which the MO instance referred
to by tAggrInstance will be sampled for Time-Based
aggregation."
::= {tAggrCtlEntry 5}
-- only one compression algorithm is defined as of now.
tAggrCtlCompressionAlgorithm OBJECT-TYPE
SYNTAX INTEGER {
none (1),
deflate (2)
}
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The compression algorithm that will be used by
the agent to compress the value of the TAgMO.
The deflate algorithm and corresponding data format
specification is described in RFC 1951. It is
compatible with the widely used gzip utility.
"
REFERENCE
"RFC1951 : DEFLATE Compressed Data Format Specification
version 1.3
"
DEFVAL { none }
::= {tAggrCtlEntry 6}
tAggrCtlEntryOwner OBJECT-TYPE
SYNTAX OwnerString
MAX-ACCESS read-create
STATUS current
Keeni Experimental [Page 21]
RFC 4498 The Managed Object Aggregation MIB May 2006
DESCRIPTION
"A textual description of the entity that created
this entry.
"
::= {tAggrCtlEntry 7}
tAggrCtlEntryStorageType OBJECT-TYPE
SYNTAX StorageType
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"This object defines whether the parameters defined in
this row are kept in volatile storage and lost upon
reboot or backed up by non-volatile (permanent)
storage.
Conceptual rows having the value 'permanent' need not
allow write-access to any columnar objects in the row.
"
::= {tAggrCtlEntry 8}
tAggrCtlEntryStatus OBJECT-TYPE
SYNTAX RowStatus
MAX-ACCESS read-create
STATUS current
DESCRIPTION
"The row status variable, used according to row
installation and removal conventions.
Objects in a row can be modified only when the value of
this object in the corresponding conceptual row is not
'active'.
Thus, to modify one or more of the objects in this
conceptual row,
a. change the row status to 'notInService',
b. change the values of the row, and
c. change the row status to 'active'.
The tAggrCtlEntryStatus may be changed to 'active' iff
all the MOs in the conceptual row have been assigned
valid values.
"
::= {tAggrCtlEntry 9}
--
-- tAggrDataTable: The data table.
--
tAggrDataTable OBJECT-TYPE
SYNTAX SEQUENCE OF TAggrDataEntry
Keeni Experimental [Page 22]
RFC 4498 The Managed Object Aggregation MIB May 2006
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"This is the data table. Each row of this table contains
information about a TAgMO indexed by tAggrCtlEntryID.
tAggrCtlEntryID is the key to the table. It is used to
identify instances of the TAgMO that are present in the
table.
"
::= {tAggrMIB 2}
tAggrDataEntry OBJECT-TYPE
SYNTAX TAggrDataEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Entry containing information pertaining
to a TAgMO."
INDEX {tAggrCtlEntryID}
::= {tAggrDataTable 1 }
TAggrDataEntry ::= SEQUENCE {
tAggrDataRecord
TimeAggrMOValue,
tAggrDataRecordCompressed
CompressedTimeAggrMOValue,
tAggrDataErrorRecord
TAggrMOErrorStatus
}
tAggrDataRecord OBJECT-TYPE
SYNTAX TimeAggrMOValue
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The snapshot value of the TAgMO."
::= { tAggrDataEntry 1}
tAggrDataRecordCompressed OBJECT-TYPE
SYNTAX CompressedTimeAggrMOValue
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The compressed value of the TAgMO.
The compression algorithm will depend on the
tAggrCtlCompressionAlgorithm given in the corresponding
tAggrCtlEntry. If the value of the corresponding
tAggrCtlCompressionAlgorithm is (1) 'none', then the
Keeni Experimental [Page 23]
RFC 4498 The Managed Object Aggregation MIB May 2006
value of all instances of this object will be a string
of zero length.
Note that the access privileges to this object will be
governed by the access privileges of the corresponding MO
instance. Thus, an entity attempting to access an
instance of this MO MUST have access rights to the
instance object pointed at by tAggrCtlMOInstance and this
MO instance.
"
::= { tAggrDataEntry 2}
tAggrDataErrorRecord OBJECT-TYPE
SYNTAX TAggrMOErrorStatus
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The error status corresponding to the MO instance
samples aggregated in tAggrDataRecord (and
tAggrDataRecordCompressed)."
::= { tAggrDataEntry 3}
-- Conformance information
tAggrConformance OBJECT IDENTIFIER ::= { tAggrMIB 3 }
tAggrGroups OBJECT IDENTIFIER ::= { tAggrConformance 1 }
tAggrCompliances OBJECT IDENTIFIER ::= { tAggrConformance 2 }
-- Compliance statements
tAggrMibCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"The compliance statement for SNMP entities
that implement the TIME-AGGREGATE-MIB."
MODULE -- this module
MANDATORY-GROUPS { tAggrMibBasicGroup }
::= { tAggrCompliances 1 }
-- Units of conformance
tAggrMibBasicGroup OBJECT-GROUP
OBJECTS {
tAggrCtlMOInstance,
tAggrCtlAgMODescr,
tAggrCtlInterval,
tAggrCtlSamples,
tAggrCtlCompressionAlgorithm,
tAggrCtlEntryOwner,
tAggrCtlEntryStorageType,
tAggrCtlEntryStatus,
Keeni Experimental [Page 24]
RFC 4498 The Managed Object Aggregation MIB May 2006
tAggrDataRecord,
tAggrDataRecordCompressed,
tAggrDataErrorRecord
}
STATUS current
DESCRIPTION
"A collection of objects for Time-Based aggregation
of MOs."
::= { tAggrGroups 1 }
END
7. Security Considerations
There are management objects in the MIB modules defined in this
document that have a MAX-ACCESS clause of read-create. Such objects
may be considered sensitive or vulnerable in some network
environments. The support for SET operations in a non-secure
environment without proper protection can have a negative effect on
network operations. The objects and corresponding vulnerabilities
are discussed below.
The following MOs are used to configure an agent that implements the
aggregate MIB modules.
aggrCtlMOIndex,
aggrCtlMODescr,
aggrCtlCompressionAlgorithm,
aggrCtlEntryOwner,
aggrCtlEntryStorageType,
aggrCtlEntryStatus,
aggrMOInstance,
aggrMODescr,
aggrMOEntryStorageType,
aggrMOEntryStatus,
tAggrCtlMOInstance,
tAggrCtlAgMODescr,
tAggrCtlInterval,
tAggrCtlSamples,
tAggrCtlCompressionAlgorithm,
tAggrCtlEntryOwner,
tAggrCtlEntryStorageType,
tAggrCtlEntryStatus,
Keeni Experimental [Page 25]
RFC 4498 The Managed Object Aggregation MIB May 2006
Access to these objects may be abused to affect the operation of the
data collection system. In particular,
- by changing the value of an instance of aggrCtlEntryStatus,
tAggrCtlEntryStatus, aggrMOEntryStatus, or tAggrMOEntryStatus
to 'notInService' or 'destroy', the data aggregation operation
for the corresponding entry will become unavailable to the
management system.
- by changing the value of an instance of aggrMOInstance or
tAggrCtlMOInstance, the data aggregation operation may be
subverted. This may result in wrong information being fed to
the management system.
- by adding several rows in the aggrMOTable corresponding to an
aggregate MO, it is possible to make the value of the aggregate
MOs very large. A similar effect may be achieved by
manipulating the value of the tAggrCtlSamples instance
corresponding to a Time-Based aggregate MO. This could result
in very heavy management traffic and/or fragmentation of
response packets. In some cases the responder may refuse to
send the data and will simply respond with an error message
indicating that the response packet size is too big.
An entity attempting to access an instance of an aggregated MO MUST
have access rights to all the component instance objects and the
aggregate MO instance. An implementation MUST follow this
requirement. Lax adherence to this requirement will breach the
security model and make the system vulnerable to illegal accesses.
SNMP versions prior to SNMPv3 did not include adequate security.
Even if the network itself is secure (for example by using IPSec),
there is no control as to who on the secure network is allowed to
access and GET/SET (read/change/create/delete) the objects in this
MIB module.
It is RECOMMENDED that implementers consider the security features as
provided by the SNMPv3 framework (see [RFC3410], section 8),
including full support for the SNMPv3 cryptographic mechanisms (for
authentication and privacy).
Further, deployment of SNMP versions prior to SNMPv3 is NOT
RECOMMENDED. Instead, it is RECOMMENDED to deploy SNMPv3 and to
enable cryptographic security. It is then a customer/operator
responsibility to ensure that the SNMP entity giving access to an
instance of this MIB module is properly configured to give access to
the objects only to those principals (users) that have legitimate
rights to indeed GET or SET (change/create/delete) them.
Keeni Experimental [Page 26]
RFC 4498 The Managed Object Aggregation MIB May 2006
8. IANA Considerations
The MIB modules in this document use the following IANA-assigned
OBJECT IDENTIFIER values, recorded in the SMI Numbers registry:
Descriptor OBJECT IDENTIFIER value
---------- -----------------------
aggrMIB { experimental 123 }
tAggrMIB { experimental 124 }
9. References
9.1. Normative References
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2578] McCloghrie, K., Perkins, D., and J. Schoenwaelder,
"Structure of Management Information Version 2 (SMIv2)",
STD 58, RFC 2578, April 1999.
[RFC2579] McCloghrie, K., Perkins, D., and J. Schoenwaelder, "Textual
Conventions for SMIv2", STD 58, RFC 2579, April 1999.
[RFC2580] McCloghrie, K., Perkins, D., and J. Schoenwaelder,
"Conformance Statements for SMIv2", STD 58, RFC 2580, April
1999.
[RFC2819] Waldbusser, S., "Remote Network Monitoring Management
Information Base", STD 59, RFC 2819, May 2000.
[RFC3411] Harrington, D., Presuhn, R., and B. Wijnen, "An
Architecture for Describing Simple Network Management
Protocol (SNMP) Management Frameworks", STD 62, RFC 3411,
December 2002.
[RFC3231] Levi, D. and J. Schoenwaelder, "Definitions of Managed
Objects for Scheduling Management Operations", RFC 3231,
January 2002.
[RFC1951] Deutsch, P., "DEFLATE Compressed Data Format Specification
version 1.3", RFC 1951, May 1996.
9.2. Informative References
[RFC3410] Case, J., Mundy, R., Partain, D., and B. Stewart,
"Introduction and Applicability Statements for Internet-
Standard Management Framework", RFC 3410, December 2002.
Keeni Experimental [Page 27]
RFC 4498 The Managed Object Aggregation MIB May 2006
10. Acknowledgements
This document is the product of discussions and deliberations carried
out in the WIDE-netman group. Bert Wijnen and Glenn Waters reviewed
the document and provided valuable comments.
Authors' Addresses
Glenn Mansfield Keeni
Cyber Solutions Inc.
6-6-3 Minami Yoshinari
Aoba-ku, Sendai 989-3204
Japan
Phone: +81-22-303-4012
EMail: glenn@cysols.com
Keeni Experimental [Page 28]
RFC 4498 The Managed Object Aggregation MIB May 2006
Full Copyright Statement
Copyright (C) The Internet Society (2006).
This document is subject to the rights, licenses and restrictions
contained in BCP 78 and at www.rfc-editor.org/copyright.html, and
except as set forth therein, the authors retain all their rights.
This document and the information contained herein are provided on an
"AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Intellectual Property
The IETF takes no position regarding the validity or scope of any
Intellectual Property Rights or other rights that might be claimed to
pertain to the implementation or use of the technology described in
this document or the extent to which any license under such rights
might or might not be available; nor does it represent that it has
made any independent effort to identify any such rights. Information
on the procedures with respect to rights in RFC documents can be
found in BCP 78 and BCP 79.
Copies of IPR disclosures made to the IETF Secretariat and any
assurances of licenses to be made available, or the result of an
attempt made to obtain a general license or permission for the use of
such proprietary rights by implementers or users of this
specification can be obtained from the IETF on-line IPR repository at
http://www.ietf.org/ipr.
The IETF invites any interested party to bring to its attention any
copyrights, patents or patent applications, or other proprietary
rights that may cover technology that may be required to implement
this standard. Please address the information to the IETF at
ietf-ipr@ietf.org.
Acknowledgement
Funding for the RFC Editor function is provided by the IETF
Administrative Support Activity (IASA).
Keeni Experimental [Page 29]