tech-invite   World Map
3GPP     Specs     Glossaries     UICC       IETF     RFCs     Groups     SIP     ABNFs       T+       Search     Home

RFC 3165

 Errata 
Proposed STD
Pages: 64
Top     in Index     Prev     Next
in Group Index     Prev in Group     Next in Group     Group: DISMAN

Definitions of Managed Objects for the Delegation of Management Scripts

Part 1 of 3, p. 1 to 12
None       Next RFC Part

Obsoletes:    2592


Top       ToC       Page 1 
Network Working Group                                            D. Levi
Request for Comments: 3165                               Nortel Networks
Obsoletes: 2592                                         J. Schoenwaelder
Category: Standards Track                                TU Braunschweig
                                                             August 2001


                 Definitions of Managed Objects for the
                    Delegation of Management Scripts

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 (2001).  All Rights Reserved.

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 set of managed objects that allow the
   delegation of management scripts to distributed managers.

Top       Page 2 
Table of Contents

   1 Introduction .................................................    3
   2 The SNMP Management Framework ................................    3
   3 Overview .....................................................    4
   3.1 Terms ......................................................    5
   4 Requirements and Design Issues ...............................    6
   4.1 Script Languages ...........................................    6
   4.2 Script Transfer ............................................    7
   4.3 Script Execution ...........................................    8
   5 Structure of the MIB .........................................    9
   5.1 Language Group .............................................    9
   5.2 Script Group ...............................................   10
   5.3 Code Group .................................................   11
   5.4 Launch Group ...............................................   11
   5.5 Run Group ..................................................   11
   6 Definitions ..................................................   12
   7 Usage Examples ...............................................   49
   7.1 Pushing a Script via SNMP ..................................   49
   7.2 Pulling a Script from a URL ................................   50
   7.3 Modifying an Existing Script ...............................   50
   7.4 Removing an Existing Script ................................   51
   7.5 Creating a Launch Button ...................................   51
   7.6 Launching a Script .........................................   52
   7.7 Suspending a Running Script ................................   52
   7.8 Resuming a Suspended Script ................................   53
   7.9 Terminating a Running Script ...............................   53
   7.10 Removing a Terminated Script ..............................   54
   7.11 Removing a Launch Button ..................................   54
   8 VACM Configuration Examples ..................................   54
   8.1 Sandbox for Guests .........................................   55
   8.2 Sharing Scripts ............................................   55
   8.3 Emergency Scripts ..........................................   56
   9 IANA Considerations ..........................................   57
   10 Security Considerations .....................................   57
   11 Intellectual Property .......................................   59
   12 Changes from RFC 2592 .......................................   59
   13 Acknowledgments .............................................   61
   14 References ..................................................   61
   15 Editors' Addresses ..........................................   63
   16 Full Copyright Statement ....................................   64

Top      ToC       Page 3 
1.  Introduction

   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 set of managed objects that allow the
   delegation of management scripts to distributed managers.

   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 RFC 2119 [RFC2119].

2.  The SNMP Management Framework

   The SNMP Management Framework presently consists of five major
   components:

   o  An overall architecture, described in RFC 2571 [RFC2571].

   o  Mechanisms for describing and naming objects and events for the
      purpose of management.  The first version of this Structure of
      Management Information (SMI) is called SMIv1 and described in STD
      16, RFC 1155 [RFC1155], STD 16, RFC 1212 [RFC1212] and RFC 1215
      [RFC1215].  The second version, called SMIv2, is described in STD
      58, RFC 2578 [RFC2578], STD 58, RFC 2579 [RFC2579] and STD 58, RFC
      2580 [RFC2580].

   o  Message protocols for transferring management information.  The
      first version of the SNMP message protocol is called SNMPv1 and
      described in STD 15, RFC 1157 [RFC1157].  A second version of the
      SNMP message protocol, which is not an Internet standards track
      protocol, is called SNMPv2c and described in RFC 1901 [RFC1901]
      and RFC 1906 [RFC1906].  The third version of the message protocol
      is called SNMPv3 and described in RFC 1906 [RFC1906], RFC 2572
      [RFC2572] and RFC 2574 [RFC2574].

   o  Protocol operations for accessing management information.  The
      first set of protocol operations and associated PDU formats is
      described in STD 15, RFC 1157 [RFC1157].  A second set of protocol
      operations and associated PDU formats is described in RFC 1905
      [RFC1905].

   o  A set of fundamental applications described in RFC 2573 [RFC2573]
      and the view-based access control mechanism described in RFC 2575
      [RFC2575].

   A more detailed introduction to the current SNMP Management Framework
   can be found in RFC 2570 [RFC2570].

Top      ToC       Page 4 
   Managed objects are accessed via a virtual information store, termed
   the Management Information Base or MIB.  Objects in the MIB are
   defined using the mechanisms defined in the SMI.

   This memo specifies a MIB module that is compliant to the SMIv2.  A
   MIB conforming to the SMIv1 can be produced through the appropriate
   translations.  The resulting translated MIB must be semantically
   equivalent, except where objects or events are omitted because no
   translation is possible (use of Counter64).  Some machine readable
   information in SMIv2 will be converted into textual descriptions in
   SMIv1 during the translation process.  However, this loss of machine
   readable information is not considered to change the semantics of the
   MIB.

3.  Overview

   The Script MIB module defined in this memo can be used to delegate
   management functions to distributed managers.  Management functions
   are defined as management scripts written in a management scripting
   language.  This MIB makes no assumptions about the language itself
   and even allows distribution of compiled native code, if an
   implementation is able to execute native code under the control of
   this MIB.

   The Script MIB defines a standard interface for the delegation of
   management functions based on the Internet management framework.  In
   particular, it provides the following capabilities:

   1. Capabilities to transfer management scripts to a distributed
      manager.

   2. Capabilities for initiating, suspending, resuming and terminating
      management scripts.

   3. Capabilities to transfer arguments for management scripts.

   4. Capabilities to monitor and control running management scripts.

   5. Capabilities to transfer the results produced by running
      management scripts.

   This memo does not address any additional topics like the generation
   of notifications or how to address remote agents from a Script MIB
   implementation.

Top      ToC       Page 5 
3.1.  Terms

   This section defines the terms used throughout this memo.

   o  A `distributed manager' is a processing entity which is capable of
      performing network management functions.  For the scope of this
      memo, a distributed manager is assumed to implement the Script
      MIB.

   o  A `higher-level manager', or just `manager', is a processing
      entity or human who initiates and controls the operations
      performed by one or more distributed managers.

   o  A `management script' is a set of instructions written in an
      executable language which implements a management function.

   o  A `management scripting language' is a language used to write
      management scripts.  The term scripting language does not imply
      that the language must have the characteristics of scripting
      languages (e.g., string orientation, interpretation, weak typing).
      The MIB defined in this memo also allows to control management
      scripts written in arbitrary compiled system programming
      languages.

   o  A `distributed manager' can be decomposed into an `SNMP entity'
      which implements the Script MIB defined in this memo and the `
      runtime system' that executes scripts.  The Script MIB sees the
      runtime system as the managed resource which is controlled by the
      MIB.

      The runtime system can act as an SNMP application, according to
      the SNMP architecture defined in RFC 2571 [RFC2571].  For example,
      a runtime system which sends SNMP requests to other SNMP entities
      will act as a command generator application.  The SNMP
      applications in the runtime system may use the same SNMP engine
      which also serves the command responder application used to
      implement the Script MIB, but they are not required to do so.

   o  A `launch button' is the conceptual button used to start the
      execution of a management script.  It assigns control parameters
      to a management script.  In particular, it defines the ownership
      of the scripts started from a launch button.  The ownership can be
      used by the language runtime system to enforce security profiles
      on a running management script.

Top      ToC       Page 6 
4.  Requirements and Design Issues

   This section discusses some general requirements that have influenced
   the design of the Script MIB.

   o  The Script MIB must not make any assumptions about specific
      languages or runtime systems.

   o  The Script MIB must provide mechanisms that help to avoid new
      management problems (e.g., script version problems).

   o  The Script MIB must provide SNMP interfaces to all functions
      required to delegate management scripts.  However, other protocols
      might be used in addition if they provide a significant
      improvement in terms of convenience for implementation or
      performance.

   o  The Script MIB must be organized so that access can be controlled
      effectively by using view-based access control [RFC2575].

   The following sections discuss some design issues in more detail.

4.1.  Script Languages

   The Script MIB defined in this memo makes no assumption about the
   script language.  This MIB can therefore be used in combination with
   different languages (such as Tcl or Java) and/or different versions
   of the same language.  No assumptions are made about the format in
   which management scripts are transferred.

   The Script MIB provides access to information about the language
   versions supported by a Script MIB implementation so that a manager
   can learn about the capabilities provided by an implementation.
   Languages and language versions are identified as follows:

   1. The language is identified by an object identifier.  Object
      identifier for well-known languages will be registered by the
      Internet Assigned Numbers Authority (IANA).  Enterprise specific
      languages can also be registered in the enterprise specific OID
      subtree.

   2. A particular version of a language is identified by a language
      version number.  The combination of a language object identifier
      and a language version is in most cases sufficient to decide
      whether a script can be executed or not.

Top      ToC       Page 7 
   3. Different implementations of the same language version might have
      differences due to ambiguities in the language definition or
      additional language features provided by an implementor.  An
      additional object identifier value is provided which identifies
      the organization which provides the implementation of a language.
      This might be used by scripts that require a particular
      implementation of a language.

   4. Finally, there might be different versions of a language
      implementation.  A version number for the language implementation
      is provided so that the manager can also distinguish between
      different implementations from the same organization of a
      particular language version.

   The version numbers can either be used by a manager to select the
   language version required to execute a particular script or to select
   a script that fits the language versions supported by a particular
   Script MIB implementation.

   An additional table lists language extensions that provide features
   not provided by the core language.  Language extensions are usually
   required to turn a general purpose language into a management
   language.  In many cases, language extensions will come in the form
   of libraries that provide capabilities like sending SNMP requests to
   remote SNMP agents or accessing the local MIB instrumentation.  Every
   extension is associated with a language and carries its own version
   numbers.

4.2.  Script Transfer

   There are two different ways to transfer management scripts to a
   distributed manager.  The first approach requires that the manager
   pushes the script to the distributed manager.  This is therefore
   called the `push model'.  The second approach is the `pull model'
   where the manager tells the distributed manager the location of the
   script and the distributed manager retrieves the script itself.

   The MIB defined in this memo supports both models.  The `push model'
   is realized by a table which allows a manager to write scripts by
   sending a sequence of SNMP set requests.  The script can be split
   into several fragments in order to deal with SNMP message size
   limitations.

   The `pull model' is realized by the use of Uniform Resource Locators
   (URLs) [RFC2396] that point to the script source.  The manager writes
   the URL which points to the script source to the distributed manager

Top      ToC       Page 8 
   by sending an SNMP set request.  The distributed manager is then
   responsible for retrieving the document using the protocol specified
   in the URL.  This allows the use of protocols like FTP [RFC959] or
   HTTP [RFC2616] to transfer large management scripts efficiently.

   The Script MIB also allows management scripts that are hard-wired
   into the Script MIB implementation.  Built-in scripts can either be
   implemented in a language runtime system, or they can be built
   natively into the Script MIB implementation.  The implementation of
   the `push model' or the `pull model' is not required.

   Scripts can be stored in non-volatile storage.  This allows a
   distributed manager to restart scripts if it is restarted (off-line
   restart).  A manager is not required to push scripts back into the
   distributed manager after a restart if the script is backed up in
   non-volatile storage.

   Every script is identified by an administratively assigned name.
   This name may be used to derive the name which is used to access the
   script in non-volatile storage.  This mapping is implementation
   specific.  However, the mapping must ensure that the Script MIB
   implementation can handle scripts with the same administrative name
   owned by different managers.  One way to achieve this is to use the
   script owner in addition to the script name in order to derive the
   internal name used to refer to a particular script in non-volatile
   storage.

4.3.  Script Execution

   The Script MIB permits execution of several instances of the same or
   different management scripts.  Script arguments are passed as OCTET
   STRING values.  Scripts return a single result value which is also an
   OCTET STRING value.  The semantic interpretation of result values is
   left to the invoking manager or other management scripts.  A script
   invoker must understand the format and semantics of both the
   arguments and the results of the scripts that it invokes.

   Scripts can also export complex results through a MIB interface.
   This allows a management application to access and use script results
   in the same manner as it processes any other MIB data.  However, the
   Script MIB does not provide any special support for the
   implementation of MIBs through scripts.

   Runtime errors terminate active scripts.  An exit code and a human
   readable error message is left in the MIB.  A notification containing
   the exit code, the error message and a timestamp is generated when a
   script terminates with an error exit code.

Top      ToC       Page 9 
   Script arguments and results do not have any size limitations other
   than the limits imposed by the SMI and the SNMP protocol.  However,
   implementations of this MIB might have further restrictions.  A
   script designer might therefore choose to return the results via
   other mechanisms if the script results can be very large.  One
   possibility is to return a URL as a script result which points to the
   file containing the script output.

   Executing scripts have a status object attached which allows script
   execution to be suspended, resumed, or aborted.  The precise
   semantics of the suspend and resume operations are language and
   runtime system dependent.  Some runtime systems may choose to not
   implement the suspend/resume operations.

   A history of finished scripts is kept in the MIB.  A script invoker
   can collect results at a later point in time (offline operation).
   Control objects can be used to control how entries in the history are
   aged out if the table fills up.

5.  Structure of the MIB

   This section presents the structure of the MIB.  The objects are
   arranged into the following groups:

   o  language group (smLangTable, smExtsnTable)

   o  script group (smScriptTable)

   o  script code group (smCodeTable)

   o  script launch group (smLaunchTable)

   o  running script group (smRunTable)

5.1.  Language Group

   The smLanguageGroup is used to provide information about the
   languages and the language extensions supported by a Script MIB
   implementation.  This group includes two tables.  The smLangTable
   lists all languages supported by a Script MIB implementation and the
   smExtsnTable lists the extensions that are available for a given
   language.

Top      ToC       Page 10 
5.2.  Script Group

   The smScriptGroup consists of a single table, called the
   smScriptTable.  The smScriptTable lists all scripts known to a Script
   MIB implementation.  The smScriptTable contains objects that allow
   the following operations:

   o  download scripts from a URL (pull model)

   o  read scripts from local non-volatile storage

   o  store scripts in local non-volatile storage

   o  delete scripts from local non-volatile storage

   o  list permanent scripts (that can not be changed or removed)

   o  read and modify the script status (enabled, disabled, editing)

   A status object called smScriptOperStatus allows a manager to obtain
   the current status of a script.  It is also used to provide an error
   indication if an attempt to invoke one of the operations listed above
   fails.  The status change of a script can be requested by modifying
   the associated smScriptAdminStatus object.

   The source of a script is defined by the smScriptSource object.  This
   object may contain a URL pointing to a remote location which provides
   access to the management script.  The script source is read from the
   smCodeTable (described below) or from non-volatile storage if the
   smScriptSource object contains an empty URL.  The smScriptStorageType
   object is used to distinguish between scripts read from non-volatile
   storage and scripts read from the smCodeTable.

   Scripts are automatically loaded once the smScriptAdminStatus object
   is set to `enabled'.  Loading a script includes retrieving the script
   (probably from a remote location), compiling the script for languages
   that require a compilation step, and making the code available to the
   runtime system.  The smScriptOperStatus object is used to indicate
   the status of the loading process.  This object will start in the
   state `retrieving', switch to the state `compiling' and finally reach
   the state `enabled'.  Errors during the retrieval or compilation
   phase will result in an error state such as `compilationFailed'.

Top      ToC       Page 11 
5.3.  Code Group

   The smCodeGroup consists of a single table, called the smCodeTable,
   which provides the ability to transfer and modify scripts via SNMP
   set requests.  In particular, the smCodeTable allows the following
   operations:

   o  download scripts via SNMP (push model)

   o  modify scripts via SNMP (editing)

   The smCodeTable lists the code of a script.  A script can be
   fragmented over multiple rows of the smCodeTable in order to handle
   SNMP message size limitations.  Modifications of the smCodeTable are
   only possible if the associated smScriptOperStatus object has the
   value `editing'.  The Script MIB implementation reloads the modified
   script code once the smScriptOperStatus changes to `enabled' again.

   The implementation of the smCodeGroup is optional.

5.4.  Launch Group

   The smLaunchGroup contains a single table, the smLaunchTable.  An
   entry in the smLaunchTable represents a launch button which can be
   used to start a script.  The smLaunchTable allows the following
   operations:

   o  associate a script with an owner used during script execution

   o  provide arguments and parameters for script invocation

   o  invoke scripts with a single set operation

   The smLaunchTable describes scripts and their parameters that are
   ready to be launched.  An entry in the smLaunchTable attaches an
   argument to a script and control values which, for example, define
   the maximum number of times that a script invoked from a particular
   row in the smLaunchTable may be running concurrently.

   An entry in the smLaunchTable also defines the owner which will be
   used to associate permissions with the script execution.

5.5.  Run Group

   The smRunGroup contains a single table, called the smRunTable, which
   lists all scripts that are currently running or have terminated
   recently.  The smRunTable contains objects that allow the following
   operations:

Top      ToC       Page 12 
   o  retrieve status information from running scripts

   o  control running scripts (suspend, resume, abort)

   o  retrieve results from recently terminated scripts

   o  control the remaining maximum lifetime of a running script

   o  control how long script results are accessible

   Every row in the smRunTable contains the argument passed during
   script invocation, the result produced by the script and the script
   exit code.  The smRunTable also provides information about the
   current run state as well as start and end time-stamps.  There are
   three writable objects in the smRunTable.  The smRunLifeTime object
   defines the maximum time a running script may run before it is
   terminated by the Script MIB implementation.  The smRunExpireTime
   object defines the time that a completed script can stay in the
   smRunTable before it is aged out.  The smRunControl object allows
   running scripts to be suspended, resumed, or aborted.



(page 12 continued on part 2)

Next RFC Part