You are here: irt.org | RFCs | RFC2287 [ previous next ]
Network Working Group C. Krupczak
Request for Comments: 2287 Empire Technologies, Inc.
Category: Standards Track J. Saperia
BGS Systems Inc.
February 1998
Definitions of System-Level Managed Objects for Applications
Status of this Memo
This document specifies an Internet standards track protocol for the
Internet community, and requests discussion and suggestions for
improvements. Please refer to the current edition of the "Internet
Official Protocol Standards" (STD 1) for the standardization state
and status of this protocol. Distribution of this memo is unlimited.
Copyright Notice
Copyright (C) The Internet Society (1998). All Rights Reserved.
Table of Contents
1 Abstract .............................................. 2
2 The SNMPv2 Network Management Framework ............... 2
2.1 Object Definitions .................................. 2
3 Overview .............................................. 3
4 Architecture for Application Management ............... 3
5 The Structure of the MIB .............................. 4
5.1 System Application Installed Group .................. 5
5.2 System Application Run Group ........................ 5
5.2.1 sysApplRunTable and sysApplPastRunTable ........... 5
5.2.2 sysApplElmtRunTable and sysApplElmtPastRunTable
.................................................... 6
5.3 System Application Map Group ........................ 7
6 Definitions ........................................... 7
7 Implementation Issues ................................. 40
7.1 Implementation with Polling Agents .................. 40
7.2 sysApplElmtPastRunTable Entry Collisions ............ 40
8 Security Considerations ............................... 41
9 Acknowledgements ...................................... 42
10 Author's Address ..................................... 42
11 References ........................................... 42
12 Full Copyright Statement ............................. 44
Krupczak & Saperia Standards Track [Page 1]
RFC 2287 MIB for Applications February 1998 1. Abstract This memo defines a portion of the Management Information Base (MIB) for use with network management protocols in the Internet community. In particular, it describes a basic set of managed objects for fault, configuration and performance management of applications from a systems perspective. More specifically, the managed objects are restricted to information that can be determined from the system itself and which does not require special instrumentation within the applications to make the information available. This memo does not specify a standard for the Internet community. 2. The SNMPv2 Network Management Framework The SNMPv2 Network Management Framework consists of the following major components: o RFC 1902 Structure of Management Information for Version 2 of the Simple Network Management Protocol (SNMPv2) [2] o RFC 1903 Textual Conventions for Version 2 of the Simple Network Management Protocol (SNMPv2) [3] o RFC 1904 Conformance Statements for Version 2 of the Simple Network Management Protocol (SNMPv2) [4] o RFC 1905 Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2) [5] o RFC 1906 Transport Mappings for Version 2 of the Simple Network Management Protocol (SNMPv2) [6] o RFC 1907 Management Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2) [7] o RFC 1908 Coexistence between Version 1 and Version 2 of the Internet-standard Network Management Framework [8] The Framework permits new objects to be defined for the purpose of experimentation and evaluation. 2.1. Object Definitions Managed objects are accessed via a virtual information store, termed the Management Information Base or MIB. Objects in the MIB are defined using the subset of Abstract Syntax Notation One (ASN.1) [1], defined in the Structure of Management Information (SMI) (See RFC Krupczak & Saperia Standards Track [Page 2]
RFC 2287 MIB for Applications February 1998 1902 [2]). In particular, each object type is named by an OBJECT IDENTIFIER, an administratively assigned name. The object type together with an object instance serves to uniquely identify a specific instantiation of the object. For human convenience, we often use a textual string, termed the object descriptor, to refer to the object type. 3. Overview The primary purpose of computing technologies is the execution of application software. These applications, typically specialized collections of executables, files, and interprocess communications, exist to solve business, scientific or other "problems". The configuration, fault detection, performance monitoring and control of application software across its life on a host computer is of great economic importance. For the purposes of our work, we define applications as one or more units of executable code and other resources, installed on a single host system that a manager may think of as a single object for management purposes. The information described by the objects in the System Application MIB support configuration, fault, and performance management; they represent some of the basic attributes of application software from a systems (non-application specific) perspective. The information allows for the description of applications as collections of executables and files installed and executing on a host computer. This memo is concerned primarily with, and defines a model for, application information resident on a host computer which can be determined from the system itself, and not from the individual applications. This system-level view of applications is designed to provide information about software applications installed and running on the host system without requiring modifications and code additions to the applications themselves. This approach was taken to insure ease and speed of implementation, while allowing room for future growth. 4. Architecture for Application Management In the area of application management it is fully acknowledged and even expected that additional MIB modules will be defined over time to provide an even greater level of detail regarding applications. This MIB module presents the most general case: a set of management objects for providing generic information about applications and whose object values can be determined from the computer system itself without requiring instrumentation within the application. Krupczak & Saperia Standards Track [Page 3]
RFC 2287 MIB for Applications February 1998 A finer-grained level of detail is planned for the future "appl MIB" which will be a common set of management objects relating to generic applications, but which require some type of instrumentation in the application in order to be determined. Since the applmib MIB module will provide a finer level of detail, any connection to the sysAppl MIB should be made by having references from the more detailed appl MIB back to the more generic sysAppl MIB. Likewise, as application- specific MIB modules such as the WWW MIB, etc., are developed over time, these more specific MIBs should reference back to the more generic MIBs. While this MIB module does not attempt to provide every detailed piece of information for managing applications, it does provide a basic systems-level view of the applications and their components on a single host system. 5. The Structure of the MIB The System Application MIB structure models application packages as a whole, and also models the individual elements (files and executables) which collectively form an application. The MIB is structured to model information regarding installed application packages and the elements which make up each application package. The MIB also models activity information on applications (and in turn, their components) that are running or have previously run on the host system. In modeling applications and their elements, this MIB module provides the necessary link for associating executing processes with the applications of which they are a part. The objects are arranged into the following groups: - System Application Installed Group - sysApplInstallPkgTable - sysApplInstallElmtTable - System Application Run Group - sysApplRunTable - sysApplPastRunTable - sysApplElmtRunTable - sysApplElmtPastRunTable - (scalars for restricting table sizes) - System Application Map Group - sysApplMapTable Krupczak & Saperia Standards Track [Page 4]
RFC 2287 MIB for Applications February 1998 As can be seen by the arrangement above, for each category, the MIB first treats an application package as a whole, and then breaks down the package to provide information about each of the elements (executable and non-executable files) of the package. 5.1. System Application Installed Group The System Application Installed group consists of two tables. Through these two tables, administrators will be able to determine which applications have been installed on a system and what their constituent components are. The first table, the sysApplInstallPkgTable, lists the application packages installed on a particular host. The second, the sysApplInstallElmtTable, provides information regarding the executables and non-executable files, or elements, which collectively compose an application. NOTE: This MIB is intended to work with applications that have been installed on a particular host, where "installed" means that the existence of the application and the association between an application and its component files can be discovered without requiring additional instrumentation of the application itself. This may require that certain conventions be used, such as using a central software installation mechanism or registry, when installing application packages. For example, many UNIX systems utilize a "pkgadd" utility to track installed application packages, while many PC systems utilize a global registry. 5.2. System Application Run Group This group models activity information for applications that have been invoked and are either currently running, or have previously run, on the host system. Likewise, the individual elements of an invoked application are also modeled to show currently running processes, and processes that have run in the past. This information is modeled using two pairs of tables: a pair of tables for currently running applications and past run applications, and a pair of tables for the currently running elements and the past run elements. Seven scalars are also defined to control the size of the past run tables. 5.2.1. sysApplRunTable and sysApplPastRunTable The sysApplRunTable and the sysApplPastRunTable make up the first pair of tables. The sysApplRunTable contains the application instances which are currently running on the host. Each time an application is invoked, a new entry is created in the sysApplRunTable to provide information about that particular invocation of the application. An entry will remain in this table until the Krupczak & Saperia Standards Track [Page 5]
RFC 2287 MIB for Applications February 1998 application instance terminates, at which time the entry will be deleted from the sysApplRunTable and placed in the sysApplPastRunTable. The sysApplPastRunTable maintains a history of instances of applications which have previously executed on the host. Entries to this table are made when an invoked application from the sysApplRunTable terminates; the table entry which represents the application instance is removed from the SysApplRunTable and a corresponding entry is added to the sysApplPastRunTable. Because the sysApplPastRunTable will continuously grow as applications are executed and terminate, two scalars are defined to control the aging-out of table entries. The value of sysApplPastRunMaxRows specifies the maximum number of entries the table may contain, while the sysApplPastRunTblTimeLimit specifies the maximum age of the table entries. Oldest entries are removed first. It is important to note that the sysApplRunTable and sysApplPastRunTable contain entries for each INVOCATION of an application. A single application package might be invoked multiple times; each invocation is properly recorded by a separate entry in the sysApplRunTable. In order to implement this group, the agent must be able to recognize that an application has been invoked, and be able to determine when that invocation terminates. This poses a complex problem since a single application invocation may involve numerous processes, some of which may be required to remain running throughout the duration of the application, others which might come and go. The sysApplInstallElmtRole columnar object in the sysApplInstallElmtTable is meant to assist in this task by indicating which element is the application's primary executable, which elements must be running in order for the application to be running, which elements are dependent on required elements, etc. See the description of sysApplInstallElmtRole for more details. 5.2.2. sysApplElmtRunTable and sysApplElmtPastRunTable While the sysApplRunTable and sysApplPastRunTable focus on applications as a whole, the sysApplElmtRunTable and sysApplElmtPastRunTable provide information regarding an application's executable elements, (processes), which are either currently executing or have executed in the past. The sysApplElmtRunTable contains an entry for every process currently running on the host. An entry is created in this table for each process at the time it is started, and will remain in the table until Krupczak & Saperia Standards Track [Page 6]
RFC 2287 MIB for Applications February 1998 the process terminates. Note that in order to provide complete information on the load on the system, this table lists EVERY running process, not just those processes that are running as part of an identified application. However, when processes terminate, only information from entries corresponding to elements of an identified application are moved to the sysApplElmtPastRunTable. The sysApplElmtPastRunTable maintains a history of processes which have previously executed on the host as part of an application. When a process from the sysApplElmtRunTable terminates, the entry's information is moved to this sysApplElmtPastRunTable provided that the process was part of an identified application. If the process cannot be associated with any 'parent' application, then it is simply removed from the sysApplElmtRunTable. This allows for processes like 'ps' or 'grep' to show up in the sysApplElmtRunTable, (where they are consuming resources and are thus "interesting"), but not in the sysApplElmtPastRunTable. Because the sysApplElmtPastRunTable will continuously grow as processes are executed and terminate, two scalars are defined to control the aging-out of table entries. The value of sysApplElmtPastRunMaxRows specifies the maximum number of entries the table may contain, while the sysApplElmtPastRunTblTimeLimit specifies the maximum age of the table entries. Oldest entries are removed first. 5.3. System Application Map Group The System Application Map group contains a single table, the sysApplMapTable, whose sole purpose is to provide a backwards mapping for determining the invoked application, installed element, and installed application package given a known process identification number. 6. Definitions SYSAPPL-MIB DEFINITIONS ::= BEGIN IMPORTS MODULE-IDENTITY, OBJECT-TYPE, Unsigned32, TimeTicks, Counter32, Gauge32 FROM SNMPv2-SMI DateAndTime, TEXTUAL-CONVENTION FROM SNMPv2-TC MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF mib-2 FROM SNMPv2-SMI; Krupczak & Saperia Standards Track [Page 7]
RFC 2287 MIB for Applications February 1998 -- System Application MIB sysApplMIB MODULE-IDENTITY LAST-UPDATED "9710200000Z" ORGANIZATION "IETF Applications MIB Working Group" CONTACT-INFO "Cheryl Krupczak (Editor, WG Advisor) Postal: Empire Technologies, Inc. 541 Tenth Street NW Suite 169 Atlanta, GA 30318 USA Phone: (770) 384-0184 Email: cheryl@empiretech.com Jon Saperia (WG Chair) Postal: BGS Systems, Inc. One First Avenue Waltham, MA 02254-9111 USA Phone: (617) 891-0000 Email: saperia@networks.bgs.com" DESCRIPTION "The MIB module defines management objects that model applications as collections of executables and files installed and executing on a host system. The MIB presents a system-level view of applications; i.e., objects in this MIB are limited to those attributes that can typically be obtained from the system itself without adding special instrumentation to the applications." ::= { mib-2 54 } sysApplOBJ OBJECT IDENTIFIER ::= { sysApplMIB 1 } sysApplInstalled OBJECT IDENTIFIER ::= { sysApplOBJ 1 } sysApplRun OBJECT IDENTIFIER ::= { sysApplOBJ 2 } sysApplMap OBJECT IDENTIFIER ::= { sysApplOBJ 3 } sysApplNotifications OBJECT IDENTIFIER ::= { sysApplMIB 2 } sysApplConformance OBJECT IDENTIFIER ::= { sysApplMIB 3 } -- Textual Conventions RunState ::= TEXTUAL-CONVENTION STATUS current DESCRIPTION "This TC describes the current execution state of a running application or process. The possible values are: Krupczak & Saperia Standards Track [Page 8]
RFC 2287 MIB for Applications February 1998 running(1), runnable(2), - waiting for a resource (CPU, etc.) waiting(3), - waiting for an event exiting(4), other(5) - other invalid state" SYNTAX INTEGER { running (1), runnable (2), -- waiting for resource (CPU, etc.) waiting (3), -- waiting for event exiting (4), other (5) -- other invalid state } LongUtf8String ::= TEXTUAL-CONVENTION DISPLAY-HINT "1024a" STATUS current DESCRIPTION "To facilitate internationalization, this TC represents information taken from the ISO/IEC IS 10646-1 character set, encoded as an octet string using the UTF-8 character encoding scheme described in RFC 2044 [10]. For strings in 7-bit US-ASCII, there is no impact since the UTF-8 representation is identical to the US-ASCII encoding." SYNTAX OCTET STRING (SIZE (0..1024)) Utf8String ::= TEXTUAL-CONVENTION DISPLAY-HINT "255a" STATUS current DESCRIPTION "To facilitate internationalization, this TC represents information taken from the ISO/IEC IS 10646-1 character set, encoded as an octet string using the UTF-8 character encoding scheme described in RFC 2044 [10]. For strings in 7-bit US-ASCII, there is no impact since the UTF-8 representation is identical to the US-ASCII encoding." SYNTAX OCTET STRING (SIZE (0..255)) -- sysApplInstalled Group -- This group provides information about application packages -- that have been installed on the host computer. The group -- contains two tables. The first, the sysApplInstallPkgTable, -- describes the application packages, the second, the -- sysApplInstallElmtTable, describes the constituent elements -- (files and executables) which compose an application package. Krupczak & Saperia Standards Track [Page 9]
RFC 2287 MIB for Applications February 1998 -- -- In order to appear in this group, an application and its -- component files must be discoverable by the system itself, -- possibly through some type of software installation mechanism -- or registry. -- sysApplInstallPkgTable -- The system installed application packages table provides -- information on the software packages installed on a system. -- These packages may consist of many different files including -- executable and non-executable files. sysApplInstallPkgTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplInstallPkgEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The table listing the software application packages installed on a host computer. In order to appear in this table, it may be necessary for the application to be installed using some type of software installation mechanism or global registry so that its existence can be detected by the agent implementation." ::= { sysApplInstalled 1 } sysApplInstallPkgEntry OBJECT-TYPE SYNTAX SysApplInstallPkgEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing an installed application package." INDEX { sysApplInstallPkgIndex } ::= { sysApplInstallPkgTable 1 } SysApplInstallPkgEntry ::= SEQUENCE { sysApplInstallPkgIndex Unsigned32, sysApplInstallPkgManufacturer Utf8String, sysApplInstallPkgProductName Utf8String, sysApplInstallPkgVersion Utf8String, sysApplInstallPkgSerialNumber Utf8String, sysApplInstallPkgDate DateAndTime, sysApplInstallPkgLocation LongUtf8String } sysApplInstallPkgIndex OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) Krupczak & Saperia Standards Track [Page 10]
RFC 2287 MIB for Applications February 1998 MAX-ACCESS not-accessible STATUS current DESCRIPTION "An integer used only for indexing purposes. Generally monotonically increasing from 1 as new applications are installed. The value for each installed application must remain constant at least from one re-initialization of the network management entity which implements this MIB module to the next re-initialization. The specific value is meaningful only within a given SNMP entity. A sysApplInstallPkgIndex value must not be re-used until the next agent entity restart in the event the installed application entry is deleted." ::= { sysApplInstallPkgEntry 1 } sysApplInstallPkgManufacturer OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The Manufacturer of the software application package." ::= { sysApplInstallPkgEntry 2 } sysApplInstallPkgProductName OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The name assigned to the software application package by the Manufacturer." ::= { sysApplInstallPkgEntry 3 } sysApplInstallPkgVersion OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The version number assigned to the application package by the manufacturer of the software." ::= { sysApplInstallPkgEntry 4 } sysApplInstallPkgSerialNumber OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current Krupczak & Saperia Standards Track [Page 11]
RFC 2287 MIB for Applications February 1998 DESCRIPTION "The serial number of the software assigned by the manufacturer." ::= { sysApplInstallPkgEntry 5 } sysApplInstallPkgDate OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The date and time this software application was installed on the host." ::= { sysApplInstallPkgEntry 6 } sysApplInstallPkgLocation OBJECT-TYPE SYNTAX LongUtf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The complete path name where the application package is installed. For example, the value would be '/opt/MyapplDir' if the application package was installed in the /opt/MyapplDir directory." ::= { sysApplInstallPkgEntry 7 } -- sysApplInstallElmtTable -- The table describing the individual application package -- elements (files and executables) installed on the host computer. sysApplInstallElmtTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplInstallElmtEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "This table details the individual application package elements (files and executables) which comprise the applications defined in the sysApplInstallPkg Table. Each entry in this table has an index to the sysApplInstallPkg table to identify the application package of which it is a part. As a result, there may be many entries in this table for each instance in the sysApplInstallPkg Table. Table entries are indexed by sysApplInstallPkgIndex, sysApplInstallElmtIndex to facilitate retrieval of all elements associated with a particular installed application package." Krupczak & Saperia Standards Track [Page 12]
RFC 2287 MIB for Applications February 1998 ::= { sysApplInstalled 2 } sysApplInstallElmtEntry OBJECT-TYPE SYNTAX SysApplInstallElmtEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing an element of an installed application. The element may be an executable or non-executable file." INDEX {sysApplInstallPkgIndex, sysApplInstallElmtIndex} ::= { sysApplInstallElmtTable 1 } SysApplInstallElmtEntry ::= SEQUENCE { sysApplInstallElmtIndex Unsigned32, sysApplInstallElmtName Utf8String, sysApplInstallElmtType INTEGER, sysApplInstallElmtDate DateAndTime, sysApplInstallElmtPath LongUtf8String, sysApplInstallElmtSizeHigh Unsigned32, sysApplInstallElmtSizeLow Unsigned32, sysApplInstallElmtRole BITS, sysApplInstallElmtModifyDate DateAndTime, sysApplInstallElmtCurSizeHigh Unsigned32, sysApplInstallElmtCurSizeLow Unsigned32 } sysApplInstallElmtIndex OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "An arbitrary integer used for indexing. The value of this index is unique among all rows in this table that exist or have existed since the last agent restart." ::= { sysApplInstallElmtEntry 1 } sysApplInstallElmtName OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The name of this element which is contained in the application." ::= { sysApplInstallElmtEntry 2 } Krupczak & Saperia Standards Track [Page 13]
RFC 2287 MIB for Applications February 1998 sysApplInstallElmtType OBJECT-TYPE SYNTAX INTEGER { unknown(1), nonexecutable(2), operatingSystem(3), -- executable deviceDriver(4), -- executable application(5) -- executable } MAX-ACCESS read-only STATUS current DESCRIPTION "The type of element that is part of the installed application." ::= { sysApplInstallElmtEntry 3 } sysApplInstallElmtDate OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The date and time that this component was installed on the system." ::= { sysApplInstallElmtEntry 4 } sysApplInstallElmtPath OBJECT-TYPE SYNTAX LongUtf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The full directory path where this element is installed. For example, the value would be '/opt/EMPuma/bin' for an element installed in the directory '/opt/EMPuma/bin'. Most application packages include information about the elements contained in the package. In addition, elements are typically installed in sub-directories under the package installation directory. In cases where the element path names are not included in the package information itself, the path can usually be determined by a simple search of the sub-directories. If the element is not installed in that location and there is no other information available to the agent implementation, then the path is unknown and null is returned." ::= { sysApplInstallElmtEntry 5} sysApplInstallElmtSizeHigh OBJECT-TYPE SYNTAX Unsigned32 MAX-ACCESS read-only STATUS current Krupczak & Saperia Standards Track [Page 14]
RFC 2287 MIB for Applications February 1998 DESCRIPTION "The installed file size in 2^32 byte blocks. This is the size of the file on disk immediately after installation. For example, for a file with a total size of 4,294,967,296 bytes, this variable would have a value of 1; for a file with a total size of 4,294,967,295 bytes this variable would be 0." ::= { sysApplInstallElmtEntry 6 } sysApplInstallElmtSizeLow OBJECT-TYPE SYNTAX Unsigned32 MAX-ACCESS read-only STATUS current DESCRIPTION "The installed file size modulo 2^32 bytes. This is the size of the file on disk immediately after installation. For example, for a file with a total size of 4,294,967,296 bytes this variable would have a value of 0; for a file with a total size of 4,294,967,295 bytes this variable would be 4,294,967,295." ::= { sysApplInstallElmtEntry 7 } sysApplInstallElmtRole OBJECT-TYPE SYNTAX BITS { executable(0), -- An application may have one or -- more executable elements. The rest of the -- bits have no meaning if the element is not -- executable. exclusive(1), -- Only one copy of an exclusive element may be -- running per invocation of the running -- application. primary(2), -- The primary executable. An application can -- have one, and only one element that is designated -- as the primary executable. The execution of -- this element constitutes an invocation of -- the application. This is used by the agent -- implementation to determine the initiation of -- an application. The primary executable must -- remain running long enough for the agent -- implementation to detect its presence. required(3), -- An application may have zero or more required -- elements. All required elements must be running Krupczak & Saperia Standards Track [Page 15]
RFC 2287 MIB for Applications February 1998 -- in order for the application to be judged to be -- running and healthy. dependent(4), -- An application may have zero or more -- dependent elements. Dependent elements may -- not be running unless required elements are. unknown(5) -- Default value for the case when an operator -- has not yet assigned one of the other values. -- When set, bits 1, 2, 3, and 4 have no meaning. } MAX-ACCESS read-write STATUS current DESCRIPTION "An operator assigned value used in the determination of application status. This value is used by the agent to determine both the mapping of started processes to the initiation of an application, as well as to allow for a determination of application health. The default value, unknown(5), is used when an operator has not yet assigned one of the other values. If unknown(5) is set, bits 1 - 4 have no meaning. The possible values are: executable(0), An application may have one or more executable elements. The rest of the bits have no meaning if the element is not executable. exclusive(1), Only one copy of an exclusive element may be running per invocation of the running application. primary(2), The primary executable. An application can have one, and only one element that is designated as the primary executable. The execution of this element constitutes an invocation of the application. This is used by the agent implementation to determine the initiation of an application. The primary executable must remain running long enough for the agent implementation to detect its presence. required(3), An application may have zero or more required elements. All required elements must be running in order for the application to be judged to be running and healthy. dependent(4), Krupczak & Saperia Standards Track [Page 16]
RFC 2287 MIB for Applications February 1998 An application may have zero or more dependent elements. Dependent elements may not be running unless required elements are. unknown(5) Default value for the case when an operator has not yet assigned one of the other values. When set, bits 1, 2, 3, and 4 have no meaning. sysApplInstallElmtRole is used by the agent implementation in determining the initiation of an application, the current state of a running application (see sysApplRunCurrentState), when an application invocation is no longer running, and the exit status of a terminated application invocation (see sysApplPastRunExitState)." DEFVAL { { unknown } } ::= { sysApplInstallElmtEntry 8 } sysApplInstallElmtModifyDate OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The date and time that this element was last modified. Modification of the sysApplInstallElmtRole columnar object does NOT constitute a modification of the element itself and should not affect the value of this object." ::= { sysApplInstallElmtEntry 9 } sysApplInstallElmtCurSizeHigh OBJECT-TYPE SYNTAX Unsigned32 MAX-ACCESS read-only STATUS current DESCRIPTION "The current file size in 2^32 byte blocks. For example, for a file with a total size of 4,294,967,296 bytes, this variable would have a value of 1; for a file with a total size of 4,294,967,295 bytes this variable would be 0." ::= { sysApplInstallElmtEntry 10 } sysApplInstallElmtCurSizeLow OBJECT-TYPE SYNTAX Unsigned32 MAX-ACCESS read-only STATUS current DESCRIPTION "The current file size modulo 2^32 bytes. For example, for a file with a total size of 4,294,967,296 Krupczak & Saperia Standards Track [Page 17]
RFC 2287 MIB for Applications February 1998 bytes this variable would have a value of 0; for a file with a total size of 4,294,967,295 bytes this variable would be 4,294,967,295." ::= { sysApplInstallElmtEntry 11 } -- sysApplRun Group -- This group models activity information for applications -- that have been invoked and are either currently running, -- or have previously run on the host system. Likewise, -- the individual elements of an invoked application are -- also modeled to show currently running processes, and -- processes that have run in the past. -- sysApplRunTable -- The sysApplRunTable contains the application instances -- which are currently running on the host. Since a single -- application might be invoked multiple times, an entry is -- added to this table for each INVOCATION of an application. -- The table is indexed by sysApplInstallPkgIndex, sysApplRunIndex -- to enable managers to easily locate all invocations of -- a particular application package. sysApplRunTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The table describes the applications which are executing on the host. Each time an application is invoked, an entry is created in this table. When an application ends, the entry is removed from this table and a corresponding entry is created in the SysApplPastRunTable. A new entry is created in this table whenever the agent implementation detects a new running process that is an installed application element whose sysApplInstallElmtRole designates it as being the application's primary executable (sysApplInstallElmtRole = primary(2) ). The table is indexed by sysApplInstallPkgIndex, sysApplRunIndex to enable managers to easily locate all invocations of a particular application package." ::= { sysApplRun 1 } sysApplRunEntry OBJECT-TYPE SYNTAX SysApplRunEntry Krupczak & Saperia Standards Track [Page 18]
RFC 2287 MIB for Applications February 1998 MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing an application which is currently running on this host." INDEX { sysApplInstallPkgIndex, sysApplRunIndex } ::= { sysApplRunTable 1 } SysApplRunEntry ::= SEQUENCE { sysApplRunIndex Unsigned32, sysApplRunStarted DateAndTime, sysApplRunCurrentState RunState } sysApplRunIndex OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table. An arbitrary integer used only for indexing purposes. Generally monotonically increasing from 1 as new applications are started on the host, it uniquely identifies application invocations. The numbering for this index increases by 1 for each INVOCATION of an application, regardless of which installed application package this entry represents a running instance of. An example of the indexing for a couple of entries is shown below. : sysApplRunStarted.17.14 sysApplRunStarted.17.63 sysApplRunStarted.18.13 : In this example, the agent has observed 12 application invocations when the application represented by entry 18 in the sysApplInstallPkgTable is invoked. The next invocation detected by the agent is an invocation of installed application package 17. Some time later, installed application 17 is invoked a second time. NOTE: this index is not intended to reflect a real-time (wall clock time) ordering of application invocations; Krupczak & Saperia Standards Track [Page 19]
RFC 2287 MIB for Applications February 1998 it is merely intended to uniquely identify running instances of applications. Although the sysApplInstallPkgIndex is included in the INDEX clause for this table, it serves only to ease searching of this table by installed application and does not contribute to uniquely identifying table entries." ::= { sysApplRunEntry 1 } sysApplRunStarted OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The date and time that the application was started." ::= { sysApplRunEntry 2 } sysApplRunCurrentState OBJECT-TYPE SYNTAX RunState MAX-ACCESS read-only STATUS current DESCRIPTION "The current state of the running application instance. The possible values are running(1), runnable(2) but waiting for a resource such as CPU, waiting(3) for an event, exiting(4), or other(5). This value is based on an evaluation of the running elements of this application instance (see sysApplElmRunState) and their Roles as defined by sysApplInstallElmtRole. An agent implementation may detect that an application instance is in the process of exiting if one or more of its REQUIRED elements are no longer running. Most agent implementations will wait until a second internal poll has been completed to give the system time to start REQUIRED elements before marking the application instance as exiting." ::= { sysApplRunEntry 3 } -- sysApplPastRunTable -- The sysApplPastRunTable provides a history of applications -- previously run on the host computer. Entries are removed from -- the sysApplRunTable and corresponding entries are added to this -- table when an application becomes inactive. Entries remain in -- this table until they are aged out when either the table size -- reaches a maximum as determined by the sysApplPastRunMaxRows, -- or when an entry has aged to exceed a time limit as set be -- sysApplPastRunTblTimeLimit. -- -- When aging out entries, the oldest entry, as determined by Krupczak & Saperia Standards Track [Page 20]
RFC 2287 MIB for Applications February 1998 -- the value of sysApplPastRunTimeEnded, will be removed first. sysApplPastRunTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplPastRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "A history of the applications that have previously run on the host computer. An entry's information is moved to this table from the sysApplRunTable when the invoked application represented by the entry ceases to be running. An agent implementation can determine that an application invocation is no longer running by evaluating the running elements of the application instance and their Roles as defined by sysApplInstallElmtRole. Obviously, if there are no running elements for the application instance, then the application invocation is no longer running. If any one of the REQUIRED elements is not running, the application instance may be in the process of exiting. Most agent implementations will wait until a second internal poll has been completed to give the system time to either restart partial failures or to give all elements time to exit. If, after the second poll, there are REQUIRED elements that are not running, then the application instance may be considered by the agent implementation to no longer be running. Entries remain in the sysApplPastRunTable until they are aged out when either the table size reaches a maximum as determined by the sysApplPastRunMaxRows, or when an entry has aged to exceed a time limit as set by sysApplPastRunTblTimeLimit. Entries in this table are indexed by sysApplInstallPkgIndex, sysApplPastRunIndex to facilitate retrieval of all past run invocations of a particular installed application." ::= { sysApplRun 2 } sysApplPastRunEntry OBJECT-TYPE SYNTAX SysApplPastRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing an invocation of an application which was previously run and has terminated. The entry is basically copied from the sysApplRunTable when the application instance terminates. Hence, the entry's Krupczak & Saperia Standards Track [Page 21]
RFC 2287 MIB for Applications February 1998 value for sysApplPastRunIndex is the same as its value was for sysApplRunIndex." INDEX { sysApplInstallPkgIndex, sysApplPastRunIndex } ::= { sysApplPastRunTable 1 } SysApplPastRunEntry ::= SEQUENCE { sysApplPastRunIndex Unsigned32, sysApplPastRunStarted DateAndTime, sysApplPastRunExitState INTEGER, sysApplPastRunTimeEnded DateAndTime } sysApplPastRunIndex OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table. An integer matching the value of the removed sysApplRunIndex corresponding to this row." ::= { sysApplPastRunEntry 1 } sysApplPastRunStarted OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The date and time that the application was started." ::= { sysApplPastRunEntry 2 } sysApplPastRunExitState OBJECT-TYPE SYNTAX INTEGER { complete (1), -- normal exit at sysApplRunTimeEnded failed (2), -- abnormal exit other (3) } MAX-ACCESS read-only STATUS current DESCRIPTION "The state of the application instance when it terminated. This value is based on an evaluation of the running elements of an application and their Roles as defined by sysApplInstallElmtRole. An application instance is said to have exited in a COMPLETE state and its entry is removed from the sysApplRunTable and added to the sysApplPastRunTable when the agent detects that ALL elements of an application invocation are no longer running. Most agent implementations will wait until a second internal poll has been completed to Krupczak & Saperia Standards Track [Page 22]
RFC 2287 MIB for Applications February 1998 give the system time to either restart partial failures or to give all elements time to exit. A failed state occurs if, after the second poll, any elements continue to run but one or more of the REQUIRED elements are no longer running. All other combinations MUST be defined as OTHER." ::= { sysApplPastRunEntry 3 } sysApplPastRunTimeEnded OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The DateAndTime the application instance was determined to be no longer running." ::= { sysApplPastRunEntry 4 } -- sysApplElmtRunTable -- The sysApplElmtRunTable contains an entry for each process that -- is currently running on the host. An entry is created in -- this table for each process at the time it is started, and will -- remain in the table until the process terminates. -- -- The table is indexed by sysApplElmtRunInstallPkg, -- sysApplElmtRunInvocID, and sysApplElmtRunIndex to make it easy -- to locate all running elements of a particular invoked application -- which has been installed on the system. sysApplElmtRunTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplElmtRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The table describes the processes which are currently executing on the host system. Each entry represents a running process and is associated with the invoked application of which that process is a part, if possible. This table contains an entry for every process currently running on the system, regardless of whether its 'parent' application can be determined. So, for example, processes like 'ps' and 'grep' will have entries though they are not associated with an installed application package. Because a running application may involve more than one executable, it is possible to have multiple entries in this table for each application. Entries are removed from this table when the process terminates. Krupczak & Saperia Standards Track [Page 23]
RFC 2287 MIB for Applications February 1998 The table is indexed by sysApplElmtRunInstallPkg, sysApplElmtRunInvocID, and sysApplElmtRunIndex to facilitate the retrieval of all running elements of a particular invoked application which has been installed on the system." ::= { sysApplRun 3 } sysApplElmtRunEntry OBJECT-TYPE SYNTAX SysApplElmtRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing a process currently running on this host. When possible, the entry is associated with the invoked application of which it is a part." INDEX { sysApplElmtRunInstallPkg, sysApplElmtRunInvocID, sysApplElmtRunIndex } ::= { sysApplElmtRunTable 1 } SysApplElmtRunEntry ::= SEQUENCE { sysApplElmtRunInstallPkg Unsigned32, sysApplElmtRunInvocID Unsigned32, sysApplElmtRunIndex Unsigned32, sysApplElmtRunInstallID Unsigned32, sysApplElmtRunTimeStarted DateAndTime, sysApplElmtRunState RunState, sysApplElmtRunName LongUtf8String, sysApplElmtRunParameters Utf8String, sysApplElmtRunCPU TimeTicks, sysApplElmtRunMemory Gauge32, sysApplElmtRunNumFiles Gauge32, sysApplElmtRunUser Utf8String } sysApplElmtRunInstallPkg OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table, this value identifies the installed software package for the application of which this process is a part. Provided that the process's 'parent' application can be determined, the value of this object is the same value as the sysApplInstallPkgIndex for the entry in the sysApplInstallPkgTable that corresponds to the installed application of which this process Krupczak & Saperia Standards Track [Page 24]
RFC 2287 MIB for Applications February 1998 is a part. If, however, the 'parent' application cannot be determined, (for example the process is not part of a particular installed application), the value for this object is then '0', signifying that this process cannot be related back to an application, and in turn, an installed software package." ::= { sysApplElmtRunEntry 1 } sysApplElmtRunInvocID OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table, this value identifies the invocation of an application of which this process is a part. Provided that the 'parent' application can be determined, the value of this object is the same value as the sysApplRunIndex for the corresponding application invocation in the sysApplRunTable. If, however, the 'parent' application cannot be determined, the value for this object is then '0', signifying that this process cannot be related back to an invocation of an application in the sysApplRunTable." ::= { sysApplElmtRunEntry 2 } sysApplElmtRunIndex OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table. A unique value for each process running on the host. Wherever possible, this should be the system's native, unique identification number." ::= { sysApplElmtRunEntry 3 } sysApplElmtRunInstallID OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS read-only STATUS current DESCRIPTION "The index into the sysApplInstallElmtTable. The Krupczak & Saperia Standards Track [Page 25]
RFC 2287 MIB for Applications February 1998 value of this object is the same value as the sysApplInstallElmtIndex for the application element of which this entry represents a running instance. If this process cannot be associated with an installed executable, the value should be '0'." ::= { sysApplElmtRunEntry 4 } sysApplElmtRunTimeStarted OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The time the process was started." ::= { sysApplElmtRunEntry 5 } sysApplElmtRunState OBJECT-TYPE SYNTAX RunState MAX-ACCESS read-only STATUS current DESCRIPTION "The current state of the running process. The possible values are running(1), runnable(2) but waiting for a resource such as CPU, waiting(3) for an event, exiting(4), or other(5)." ::= { sysApplElmtRunEntry 6 } sysApplElmtRunName OBJECT-TYPE SYNTAX LongUtf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The full path and filename of the process. For example, '/opt/MYYpkg/bin/myyproc' would be returned for process 'myyproc' whose execution path is '/opt/MYYpkg/bin/myyproc'." ::= { sysApplElmtRunEntry 7 } sysApplElmtRunParameters OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The starting parameters for the process." ::= { sysApplElmtRunEntry 8 } sysApplElmtRunCPU OBJECT-TYPE SYNTAX TimeTicks MAX-ACCESS read-only Krupczak & Saperia Standards Track [Page 26]
RFC 2287 MIB for Applications February 1998 STATUS current DESCRIPTION "The number of centi-seconds of the total system's CPU resources consumed by this process. Note that on a multi-processor system, this value may have been incremented by more than one centi-second in one centi-second of real (wall clock) time." ::= { sysApplElmtRunEntry 9 } sysApplElmtRunMemory OBJECT-TYPE SYNTAX Gauge32 UNITS "Kbytes" MAX-ACCESS read-only STATUS current DESCRIPTION "The total amount of real system memory measured in Kbytes currently allocated to this process." ::= { sysApplElmtRunEntry 10 } sysApplElmtRunNumFiles OBJECT-TYPE SYNTAX Gauge32 MAX-ACCESS read-only STATUS current DESCRIPTION "The number of regular files currently open by the process. Transport connections (sockets) should NOT be included in the calculation of this value, nor should operating system specific special file types." ::= { sysApplElmtRunEntry 11 } sysApplElmtRunUser OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The process owner's login name (e.g. root)." ::= { sysApplElmtRunEntry 12 } -- sysApplElmtPastRunTable -- The sysApplElmtPastRunTable maintains a history of -- processes which have previously executed on -- the host as part of an application. Upon termination -- of a process, the entry representing the process is removed from -- the sysApplElmtRunTable and a corresponding entry is created in -- this table provided that the process was part of an -- identifiable application. If the process could not be associated Krupczak & Saperia Standards Track [Page 27]
RFC 2287 MIB for Applications February 1998 -- with an invoked application, no corresponding entry is created. -- Hence, whereas the sysApplElmtRunTable contains an entry for -- every process currently executing on the system, the -- sysApplElmtPastRunTable only contains entries for processes -- that previously executed as part of an invoked application. -- -- Entries remain in this table until they are aged out when -- either the number of entries in the table reaches a -- maximum as determined by sysApplElmtPastRunMaxRows, or -- when an entry has aged to exceed a time limit as set by -- sysApplElmtPastRunTblTimeLimit. When aging out entries, -- the oldest entry, as determined by the value of -- sysApplElmtPastRunTimeEnded, will be removed first. -- -- The table is indexed by sysApplInstallPkgIndex (from the -- sysApplInstallPkgTable), sysApplElmtPastRunInvocID, and -- sysApplElmtPastRunIndex to make it easy to locate all -- previously executed processes of a particular invoked application -- that has been installed on the system. sysApplElmtPastRunTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplElmtPastRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The table describes the processes which have previously executed on the host system as part of an application. Each entry represents a process which has previously executed and is associated with the invoked application of which it was a part. Because an invoked application may involve more than one executable, it is possible to have multiple entries in this table for each application invocation. Entries are added to this table when the corresponding process in the sysApplElmtRun Table terminates. Entries remain in this table until they are aged out when either the number of entries in the table reaches a maximum as determined by sysApplElmtPastRunMaxRows, or when an entry has aged to exceed a time limit as set by sysApplElmtPastRunTblTimeLimit. When aging out entries, the oldest entry, as determined by the value of sysApplElmtPastRunTimeEnded, will be removed first. The table is indexed by sysApplInstallPkgIndex (from the sysApplInstallPkgTable), sysApplElmtPastRunInvocID, and sysApplElmtPastRunIndex to make it easy to locate all Krupczak & Saperia Standards Track [Page 28]
RFC 2287 MIB for Applications February 1998 previously executed processes of a particular invoked application that has been installed on the system." ::= { sysApplRun 4 } sysApplElmtPastRunEntry OBJECT-TYPE SYNTAX SysApplElmtPastRunEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The logical row describing a process which was previously executed on this host as part of an installed application. The entry is basically copied from the sysApplElmtRunTable when the process terminates. Hence, the entry's value for sysApplElmtPastRunIndex is the same as its value was for sysApplElmtRunIndex. Note carefully: only those processes which could be associated with an identified application are included in this table." INDEX { sysApplInstallPkgIndex, sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex } ::= { sysApplElmtPastRunTable 1 } SysApplElmtPastRunEntry ::= SEQUENCE { sysApplElmtPastRunInvocID Unsigned32, sysApplElmtPastRunIndex Unsigned32, sysApplElmtPastRunInstallID Unsigned32, sysApplElmtPastRunTimeStarted DateAndTime, sysApplElmtPastRunTimeEnded DateAndTime, sysApplElmtPastRunName LongUtf8String, sysApplElmtPastRunParameters Utf8String, sysApplElmtPastRunCPU TimeTicks, sysApplElmtPastRunMemory Unsigned32, sysApplElmtPastRunNumFiles Unsigned32, sysApplElmtPastRunUser Utf8String } sysApplElmtPastRunInvocID OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table, this value identifies the invocation of an application of which the process represented by this entry was a part. The value of this object is the same value as the sysApplRunIndex for the corresponding application invocation in the sysApplRunTable. If the invoked application as a whole has terminated, it will be the Krupczak & Saperia Standards Track [Page 29]
RFC 2287 MIB for Applications February 1998 same as the sysApplPastRunIndex." ::= { sysApplElmtPastRunEntry 1 } sysApplElmtPastRunIndex OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "Part of the index for this table. An integer assigned by the agent equal to the corresponding sysApplElmtRunIndex which was removed from the sysApplElmtRunTable and moved to this table when the element terminated. Note: entries in this table are indexed by sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex. The possibility exists, though unlikely, of a collision occurring by a new entry which was run by the same invoked application (InvocID), and was assigned the same process identification number (ElmtRunIndex) as an element which was previously run by the same invoked application. Should this situation occur, the new entry replaces the old entry. See Section: 'Implementation Issues - sysApplElmtPastRunTable Entry Collisions' for the conditions that would have to occur in order for a collision to occur." ::= { sysApplElmtPastRunEntry 2 } sysApplElmtPastRunInstallID OBJECT-TYPE SYNTAX Unsigned32 (1..'ffffffff'h) MAX-ACCESS read-only STATUS current DESCRIPTION "The index into the installed element table. The value of this object is the same value as the sysApplInstallElmtIndex for the application element of which this entry represents a previously executed process." ::= { sysApplElmtPastRunEntry 3 } sysApplElmtPastRunTimeStarted OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only Krupczak & Saperia Standards Track [Page 30]
RFC 2287 MIB for Applications February 1998 STATUS current DESCRIPTION "The time the process was started." ::= { sysApplElmtPastRunEntry 4 } sysApplElmtPastRunTimeEnded OBJECT-TYPE SYNTAX DateAndTime MAX-ACCESS read-only STATUS current DESCRIPTION "The time the process ended." ::= { sysApplElmtPastRunEntry 5 } sysApplElmtPastRunName OBJECT-TYPE SYNTAX LongUtf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The full path and filename of the process. For example, '/opt/MYYpkg/bin/myyproc' would be returned for process 'myyproc' whose execution path was '/opt/MYYpkg/bin/myyproc'." ::= { sysApplElmtPastRunEntry 6 } sysApplElmtPastRunParameters OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The starting parameters for the process." ::= { sysApplElmtPastRunEntry 7 } sysApplElmtPastRunCPU OBJECT-TYPE SYNTAX TimeTicks MAX-ACCESS read-only STATUS current DESCRIPTION "The last known number of centi-seconds of the total system's CPU resources consumed by this process. Note that on a multi-processor system, this value may increment by more than one centi-second in one centi-second of real (wall clock) time." ::= { sysApplElmtPastRunEntry 8 } sysApplElmtPastRunMemory OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) UNITS "Kbytes" MAX-ACCESS read-only Krupczak & Saperia Standards Track [Page 31]
RFC 2287 MIB for Applications February 1998 STATUS current DESCRIPTION "The last known total amount of real system memory measured in Kbytes allocated to this process before it terminated." ::= { sysApplElmtPastRunEntry 9 } sysApplElmtPastRunNumFiles OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS read-only STATUS current DESCRIPTION "The last known number of files open by the process before it terminated. Transport connections (sockets) should NOT be included in the calculation of this value." ::= { sysApplElmtPastRunEntry 10 } sysApplElmtPastRunUser OBJECT-TYPE SYNTAX Utf8String MAX-ACCESS read-only STATUS current DESCRIPTION "The process owner's login name (e.g. root)." ::= { sysApplElmtPastRunEntry 11 } -- Additional Scalar objects to control table sizes sysApplPastRunMaxRows OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS read-write STATUS current DESCRIPTION "The maximum number of entries allowed in the sysApplPastRunTable. Once the number of rows in the sysApplPastRunTable reaches this value, the management subsystem will remove the oldest entry in the table to make room for the new entry to be added. Entries will be removed on the basis of oldest sysApplPastRunTimeEnded value first. This object may be used to control the amount of system resources that can used for sysApplPastRunTable entries. A conforming implementation should attempt to support the default value, however, a lesser value may be necessary due to implementation-dependent issues and resource availability." Krupczak & Saperia Standards Track [Page 32]
RFC 2287 MIB for Applications February 1998 DEFVAL { 500 } ::= { sysApplRun 5 } sysApplPastRunTableRemItems OBJECT-TYPE SYNTAX Counter32 MAX-ACCESS read-only STATUS current DESCRIPTION "A counter of the number of entries removed from the sysApplPastRunTable because of table size limitations as set in sysApplPastRunMaxRows. This counter is the number of entries the management subsystem has had to remove in order to make room for new entries (so as not to exceed the limit set by sysApplPastRunMaxRows) since the last initialization of the management subsystem." ::= { sysApplRun 6 } sysApplPastRunTblTimeLimit OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) UNITS "seconds" MAX-ACCESS read-write STATUS current DESCRIPTION "The maximum time in seconds which an entry in the sysApplPastRunTable may exist before it is removed. Any entry that is older than this value will be removed (aged out) from the table. Note that an entry may be aged out prior to reaching this time limit if it is the oldest entry in the table and must be removed to make space for a new entry so as to not exceed sysApplPastRunMaxRows." DEFVAL { 7200 } ::= { sysApplRun 7 } sysApplElemPastRunMaxRows OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS read-write STATUS current DESCRIPTION "The maximum number of entries allowed in the sysApplElmtPastRunTable. Once the number of rows in the sysApplElmtPastRunTable reaches this value, the management subsystem will remove the oldest entry to make room for the new entry to be added. Entries will be removed on the basis of oldest sysApplElmtPastRunTimeEnded value first. Krupczak & Saperia Standards Track [Page 33]
RFC 2287 MIB for Applications February 1998 This object may be used to control the amount of system resources that can used for sysApplElemPastRunTable entries. A conforming implementation should attempt to support the default value, however, a lesser value may be necessary due to implementation-dependent issues and resource availability." DEFVAL { 500 } ::= { sysApplRun 8 } sysApplElemPastRunTableRemItems OBJECT-TYPE SYNTAX Counter32 MAX-ACCESS read-only STATUS current DESCRIPTION "A counter of the number of entries removed from the sysApplElemPastRunTable because of table size limitations as set in sysApplElemPastRunMaxRows. This counter is the number of entries the management subsystem has had to remove in order to make room for new entries (so as not to exceed the limit set by sysApplElemPastRunMaxRows) since the last initialization of the management subsystem." ::= { sysApplRun 9 } sysApplElemPastRunTblTimeLimit OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) UNITS "seconds" MAX-ACCESS read-write STATUS current DESCRIPTION "The maximum time in seconds which an entry in the sysApplElemPastRunTable may exist before it is removed. Any entry that is older than this value will be removed (aged out) from the table. Note that an entry may be aged out prior to reaching this time limit if it is the oldest entry in the table and must be removed to make space for a new entry so as to not exceed sysApplElemPastRunMaxRows." DEFVAL { 7200 } ::= { sysApplRun 10 } sysApplAgentPollInterval OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) UNITS "seconds" MAX-ACCESS read-write STATUS current DESCRIPTION "The minimum interval in seconds that the management Krupczak & Saperia Standards Track [Page 34]
RFC 2287 MIB for Applications February 1998 subsystem implementing this MIB will poll the status of the managed resources. Because of the non-trivial effort involved in polling the managed resources, and because the method for obtaining the status of the managed resources is implementation-dependent, a conformant implementation may chose a lower bound greater than 0. A value of 0 indicates that there is no delay in the passing of information from the managed resources to the agent." DEFVAL { 60 } ::= { sysApplRun 11 } -- sysApplMap Group -- This group contains a table, the sysApplMapTable, -- whose sole purpose is to provide a 'backwards' -- mapping so that, given a known sysApplElmtRunIndex -- (process identification number), the corresponding invoked -- application (sysApplRunIndex), installed element -- (sysApplInstallElmtIndex), and installed application -- package (sysApplInstallPkgIndex) can be quickly determined. -- -- The table will contain one entry for each process -- currently running on the system. -- -- A backwards mapping is extremely useful since the tables -- in this MIB module are typically indexed with the -- installed application package (sysApplInstallPkgIndex) -- as the primary key, and on down as required by the -- specific table, with the process ID number (sysApplElmtRunIndex) -- being the least significant key. -- -- It is expected that management applications will use -- this mapping table by doing a 'GetNext' operation with -- the known process ID number (sysApplElmtRunIndex) as the partial -- instance identifier. Assuming that there is an entry for -- the process, the result should return a single columnar value, -- the sysApplMapInstallPkgIndex, with the sysApplElmtRunIndex, -- sysApplRunIndex, and sysApplInstallElmtIndex contained in the -- instance identifier for the returned MIB object value. -- -- NOTE: if the process can not be associated back to an -- invoked application installed on the system, then the -- value returned for the columnar value sysApplMapInstallPkgIndex -- will be '0' and the instance portion of the object-identifier -- will be the process ID number (sysApplElmtRunIndex) followed Krupczak & Saperia Standards Track [Page 35]
RFC 2287 MIB for Applications February 1998 -- by 0.0. sysApplMapTable OBJECT-TYPE SYNTAX SEQUENCE OF SysApplMapEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "The sole purpose of this table is to provide a 'backwards' mapping so that, given a known sysApplElmtRunIndex (process identification number), the corresponding invoked application (sysApplRunIndex), installed element (sysApplInstallElmtIndex), and installed application package (sysApplInstallPkgIndex) can be quickly determined. This table will contain one entry for each process that is currently executing on the system. It is expected that management applications will use this mapping table by doing a 'GetNext' operation with the known process ID number (sysApplElmtRunIndex) as the partial instance identifier. Assuming that there is an entry for the process, the result should return a single columnar value, the sysApplMapInstallPkgIndex, with the sysApplElmtRunIndex, sysApplRunIndex, and sysApplInstallElmtIndex contained in the instance identifier for the returned MIB object value. NOTE: if the process can not be associated back to an invoked application installed on the system, then the value returned for the columnar value sysApplMapInstallPkgIndex will be '0' and the instance portion of the object-identifier will be the process ID number (sysApplElmtRunIndex) followed by 0.0." ::= { sysApplMap 1 } sysApplMapEntry OBJECT-TYPE SYNTAX SysApplMapEntry MAX-ACCESS not-accessible STATUS current DESCRIPTION "A logical row representing a process currently running on the system. This entry provides the index mapping from process identifier, back to the invoked application, installed element, and finally, the installed application package. The entry includes only one accessible columnar object, the sysApplMapInstallPkgIndex, but the invoked application and installed element can be Krupczak & Saperia Standards Track [Page 36]
RFC 2287 MIB for Applications February 1998 determined from the instance identifier since they form part of the index clause." INDEX { sysApplElmtRunIndex, sysApplElmtRunInvocID, sysApplMapInstallElmtIndex } ::= { sysApplMapTable 1 } SysApplMapEntry ::= SEQUENCE { sysApplMapInstallElmtIndex Unsigned32, sysApplMapInstallPkgIndex Unsigned32 } sysApplMapInstallElmtIndex OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS not-accessible STATUS current DESCRIPTION "The index into the sysApplInstallElmtTable. The value of this object is the same value as the sysApplInstallElmtIndex for the application element of which this entry represents a running instance. If this process cannot be associated to an installed executable, the value should be '0'." ::= { sysApplMapEntry 1 } sysApplMapInstallPkgIndex OBJECT-TYPE SYNTAX Unsigned32 (0..'ffffffff'h) MAX-ACCESS read-only STATUS current DESCRIPTION "The value of this object identifies the installed software package for the application of which this process is a part. Provided that the process's 'parent' application can be determined, the value of this object is the same value as the sysApplInstallPkgIndex for the entry in the sysApplInstallPkgTable that corresponds to the installed application of which this process is a part. If, however, the 'parent' application cannot be determined, (for example the process is not part of a particular installed application), the value for this object is then '0', signifying that this process cannot be related back to an application, and in turn, an installed software package." ::= { sysApplMapEntry 2 } -- Conformance Macros Krupczak & Saperia Standards Track [Page 37]
RFC 2287 MIB for Applications February 1998 sysApplMIBCompliances OBJECT IDENTIFIER ::= { sysApplConformance 1 } sysApplMIBGroups OBJECT IDENTIFIER ::= { sysApplConformance 2 } sysApplMIBCompliance MODULE-COMPLIANCE STATUS current DESCRIPTION "Describes the requirements for conformance to the System Application MIB" MODULE -- this module MANDATORY-GROUPS { sysApplInstalledGroup, sysApplRunGroup, sysApplMapGroup } ::= { sysApplMIBCompliances 1 } sysApplInstalledGroup OBJECT-GROUP OBJECTS { sysApplInstallPkgManufacturer, sysApplInstallPkgProductName, sysApplInstallPkgVersion, sysApplInstallPkgSerialNumber, sysApplInstallPkgDate, sysApplInstallPkgLocation, sysApplInstallElmtName, sysApplInstallElmtType, sysApplInstallElmtDate, sysApplInstallElmtPath, sysApplInstallElmtSizeHigh, sysApplInstallElmtSizeLow, sysApplInstallElmtRole, sysApplInstallElmtModifyDate, sysApplInstallElmtCurSizeHigh, sysApplInstallElmtCurSizeLow } STATUS current DESCRIPTION "The system application installed group contains information about applications and their constituent components which have been installed on the host system." ::= { sysApplMIBGroups 1 } sysApplRunGroup OBJECT-GROUP OBJECTS { sysApplRunStarted, sysApplRunCurrentState, sysApplPastRunStarted, sysApplPastRunExitState, sysApplPastRunTimeEnded, sysApplElmtRunInstallID, sysApplElmtRunTimeStarted, sysApplElmtRunState, sysApplElmtRunName, sysApplElmtRunParameters, Krupczak & Saperia Standards Track [Page 38]
RFC 2287 MIB for Applications February 1998 sysApplElmtRunCPU, sysApplElmtRunMemory, sysApplElmtRunNumFiles, sysApplElmtRunUser, sysApplElmtPastRunInstallID, sysApplElmtPastRunTimeStarted, sysApplElmtPastRunTimeEnded, sysApplElmtPastRunName, sysApplElmtPastRunParameters, sysApplElmtPastRunCPU, sysApplElmtPastRunMemory, sysApplElmtPastRunNumFiles, sysApplElmtPastRunUser, sysApplPastRunMaxRows, sysApplPastRunTableRemItems, sysApplPastRunTblTimeLimit, sysApplElemPastRunMaxRows, sysApplElemPastRunTableRemItems, sysApplElemPastRunTblTimeLimit, sysApplAgentPollInterval } STATUS current DESCRIPTION "The system application run group contains information about applications and associated elements which have run or are currently running on the host system." ::= { sysApplMIBGroups 2 } sysApplMapGroup OBJECT-GROUP OBJECTS { sysApplMapInstallPkgIndex } STATUS current DESCRIPTION "The Map Group contains a single table, sysApplMapTable, that provides a backwards mapping for determining the invoked application, installed element, and installed application package given a known process identification number." ::= { sysApplMIBGroups 3 } END Krupczak & Saperia Standards Track [Page 39]
RFC 2287 MIB for Applications February 1998 7. Implementation Issues This section discusses implementation issues that are important for both an agent developer, and a management application developer or user to understand with regards to this MIB module. Although this section does not attempt to prescribe a particular implementation strategy, it does attempt to recognize some of the real world limitations that could effect an implementation of this MIB module. 7.1. Implementation with Polling Agents Implementations of the System Application MIB on popular operating systems might require some considerable processing power to obtain status information from the managed resources. It might also be difficult to determine when an application or a process starts or finishes. Implementors of this MIB might therefore choose an implementation approach where the agent polls the managed resources at regular intervals. The information retrieved by every poll is used to update a cached version of this MIB maintained inside of the agent. SNMP request are processed based on the information found in this MIB cache. A scalar sysApplAgentPollInterval is defined to give the manager control over the polling frequency. There is a trade- off between the amount of resources consumed during every poll to update the MIB cache, and the accuracy of the information provided by the System Application MIB agent. A default value of 60 seconds is defined to keep the processing overhead low, while providing usable information for long-lived processes. A manager is expected to adjust this value if more accurate information about short-lived applications or processes is needed, or if the amount of resources consumed by the agent is too high. 7.2. sysApplElmtPastRunTable Entry Collisions The sysApplElmtPastRunTable maintains a history of processes which have previously executed on the host as part of an application. Information is moved from the sysApplElmtRunTable to this PastRun table when the process represented by the entry terminates. The sysApplElmtPastRunTable is indexed by the tuple, (sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex), where the first part identifies the application invocation of which the process was a part, and the second part identifies the process itself. Recall that the sysApplElmtRunIndex represents the system's unique identification number assigned to a running process and that this value is mapped to sysApplElmtPastRunIndex when the process Krupczak & Saperia Standards Track [Page 40]
RFC 2287 MIB for Applications February 1998 terminates and the entry's information is moved from the sysApplElmtRunTable to the sysApplElmtPastRunTable. Many systems re-use process ID numbers which are no longer assigned to running processes; typically, the process numbers wrap and the next available process number is used. It is therefore possible for two entries in the sysApplElmtPastRun Table to have the same value for sysApplElmtPastRunIndex. For this reason, entries in the ElmtPastRun table are indexed by the tuple sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex to reduce the chance of a collision by two past run elements with the same sysApplElmtPastRunIndex. However, it is still possible, though unlikely, for a collision to occur if the following happens: 1) the invoked application (identified by InvocID), has an element which runs, terminates, and is moved into the sysApplElmtPastRun table (index: InvocID, RunIndex) 2) the numbers used for the system's process identification numbering wrap 3) that same invoked application (same InvocID), has another element process run, AND that process is assigned the same identification number as one of the processes previously run by that invoked application (same RunIndex), and finally, 4) that element process terminates and is moved to the sysApplElmtPastRun table prior to the old, duplicate (InvocID, RunIndex) entry being aged out of the table by settings defined for sysApplElmtPastRunMaxRows and sysApplElmtPastRunTblTimeLimit. In the event that a collision occurs, the new entry will replace the old entry. 8. Security Considerations In order to implement this MIB, an agent must make certain management information available about various logical and physical entities within a managed system which may be considered sensitive in some network environments. Therefore, a network administrator may wish to employ instance-level access control, and configure the access mechanism (i.e., community strings in SNMPv1 and SNMPv2C), such that certain instances within this MIB are excluded from particular MIB views. Krupczak & Saperia Standards Track [Page 41]
RFC 2287 MIB for Applications February 1998 9. Acknowledgements This document was produced by the Application MIB working group. Special acknowledgement is made to: Rick Sturm Enterprise Management Professional Services, Inc. sturm@emi-summit.com For hosting the working group mailing list, and for his participation in the development of the initial draft. Jon Weinstock General Instrument Corporation jweinstock@gic.gi.com For his participation in the development of the initial drafts and for serving as editor for drafts 1 and 2. The editor would like to extend special thanks to the following working group members for their contributions to this effort. Harald Alvestrand, George Best, Ian Hanson, Harrie Hazewinkel, Carl Kalbfleisch, Bobby Krupczak, Randy Presuhn, Jon Saperia, Juergen Schoenwaelder 11. Author's Address Cheryl Krupczak Empire Technologies, Inc. 541 Tenth Street, NW Suite 169 Atlanta, GA 30318 Phone: 770.384.0184 EMail: cheryl@empiretech.com Jonathan Saperia BGS Systems Inc. saperia@networks.bgs.com 12. References [1] Information processing systems - Open Systems Interconnection - Specification of Abstract Syntax Notation One (ASN.1), International Organization for Standardization. International Standard 8824, (December, 1987). Krupczak & Saperia Standards Track [Page 42]
RFC 2287 MIB for Applications February 1998 [2] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Structure of Management Information for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1902, January 1996. [3] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Textual Conventions for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1903, January 1996. [4] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Conformance Statements for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1904, January 1996. [5] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1905, January 1996. [6] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Transport Mappings for SNMPv2", RFC 1906, January 1996. [7] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Management Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1907, January 1996. [8] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Coexistence between Version 1 and Version 2 of the Internet-standard Network Management Framework", RFC 1908, January 1996. [9] Grillo, P., and S. Waldbusser, "Host Resources MIB", RFC 1514, September 1993. [10] Yergeau, F., "UTF-8, a transformation format of Unicode and ISO 10646", RFC 2044, October 1996. [11] Krupczak, C., and S. Waldbusser, "Applicability of Host Resources MIB to Application Management", Application MIB working group report, October 1995. Krupczak & Saperia Standards Track [Page 43]
RFC 2287 MIB for Applications February 1998 12. Full Copyright Statement Copyright (C) The Internet Society (1998). All Rights Reserved. This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English. The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns. This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS 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. Krupczak & Saperia Standards Track [Page 44]