disman_expression_mib

package
v0.0.0-...-50def94 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 2, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

The MIB module for defining expressions of MIB objects for management purposes.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DISMANEXPRESSIONMIB 

type DISMANEXPRESSIONMIB struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	ExpResource DISMANEXPRESSIONMIB_ExpResource

	// A table of expression definitions.
	ExpExpressionTable DISMANEXPRESSIONMIB_ExpExpressionTable

	// A table of expression errors.
	ExpErrorTable DISMANEXPRESSIONMIB_ExpErrorTable

	// A table of object definitions for each expExpression.  Wildcarding instance
	// IDs:  It is legal to omit all or part of the instance portion for some or
	// all of the objects in an expression. (See the DESCRIPTION of expObjectID
	// for details.  However, note that if more than one object in the same
	// expression is wildcarded in this way, they all must be objects where that
	// portion of the instance is the same.  In other words, all objects may be in
	// the same SEQUENCE or in different SEQUENCEs but with the same semantic
	// index value (e.g., a value of ifIndex) for the wildcarded portion.
	ExpObjectTable DISMANEXPRESSIONMIB_ExpObjectTable

	// A table of values from evaluated expressions.
	ExpValueTable DISMANEXPRESSIONMIB_ExpValueTable
}

DISMANEXPRESSIONMIB

func (*DISMANEXPRESSIONMIB) GetEntityData 

func (dISMANEXPRESSIONMIB *DISMANEXPRESSIONMIB) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpErrorTable 

type DISMANEXPRESSIONMIB_ExpErrorTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Information about errors in processing an expression.  Entries appear in
	// this table only when there is a matching expExpressionEntry and then only
	// when there has been an error for that expression as reflected by the error
	// codes defined for expErrorCode. The type is slice of
	// DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry.
	ExpErrorEntry []*DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry
}

DISMANEXPRESSIONMIB_ExpErrorTable A table of expression errors.

func (*DISMANEXPRESSIONMIB_ExpErrorTable) GetEntityData 

func (expErrorTable *DISMANEXPRESSIONMIB_ExpErrorTable) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry 

type DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with length: 0..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionOwner
	ExpExpressionOwner interface{}

	// This attribute is a key. The type is string with length: 1..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionName
	ExpExpressionName interface{}

	// The value of sysUpTime the last time an error caused a failure to evaluate
	// this expression. The type is interface{} with range: 0..4294967295.
	ExpErrorTime interface{}

	// The one-dimensioned character array index into expExpression for where the
	// error occurred.  The value zero indicates irrelevance. The type is
	// interface{} with range: -2147483648..2147483647.
	ExpErrorIndex interface{}

	// The error that occurred.  In the following explanations the expected timing
	// of the error is in parentheses.  'S' means the error occurs on a Set
	// request.  'E' means the error occurs on the attempt to evaluate the
	// expression either due to Get from expValueTable or in ongoing delta
	// processing.  invalidSyntax       the value sent for expExpression is not
	// valid Expression MIB expression syntax                (S)
	// undefinedObjectIndex     an object reference ($n) in
	// expExpression does not have a matching                instance in
	// expObjectTable (E) unrecognizedOperator     the value sent for
	// expExpression held an                unrecognized operator (S)
	// unrecognizedFunction     the value sent for expExpression held an
	// unrecognized function name (S) invalidOperandType  an operand in
	// expExpression is not the                right type for the associated
	// operator                or result (SE) unmatchedParenthesis     the value
	// sent for expExpression is not                correctly parenthesized (S)
	// tooManyWildcardValues    evaluating the expression exceeded the
	// limit set by                expResourceDeltaWildcardInstanceMaximum
	// (E) recursion      through some chain of embedded
	// expressions the expression invokes itself                (E) deltaTooShort
	// the delta for the next evaluation passed                before the system
	// could evaluate the                present sample (E) resourceUnavailable
	// some resource, typically dynamic memory,                was unavailable
	// (SE) divideByZero        an attempt to divide by zero occurred
	// (E)  For the errors that occur when the attempt is made to set
	// expExpression Set request fails with the SNMP error code 'wrongValue'.
	// Such failures refer to the most recent failure to Set expExpression, not to
	// the present value of expExpression which must be either unset or
	// syntactically correct.  Errors that occur during evaluation for a Get*
	// operation return the SNMP error code 'genErr' except for
	// 'tooManyWildcardValues' and 'resourceUnavailable' which return the SNMP
	// error code 'resourceUnavailable'. The type is ExpErrorCode.
	ExpErrorCode interface{}

	// The expValueInstance being evaluated when the error occurred.  A
	// zero-length indicates irrelevance. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpErrorInstance interface{}
}

DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry Information about errors in processing an expression.

Entries appear in this table only when there is a matching expExpressionEntry and then only when there has been an error for that expression as reflected by the error codes defined for expErrorCode.

func (*DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry) GetEntityData 

func (expErrorEntry *DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode 

type DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode string

DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode represents 'resourceUnavailable'. 

const (
	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_invalidSyntax DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "invalidSyntax"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_undefinedObjectIndex DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "undefinedObjectIndex"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_unrecognizedOperator DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "unrecognizedOperator"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_unrecognizedFunction DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "unrecognizedFunction"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_invalidOperandType DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "invalidOperandType"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_unmatchedParenthesis DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "unmatchedParenthesis"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_tooManyWildcardValues DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "tooManyWildcardValues"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_recursion DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "recursion"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_deltaTooShort DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "deltaTooShort"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_resourceUnavailable DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "resourceUnavailable"

	DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode_divideByZero DISMANEXPRESSIONMIB_ExpErrorTable_ExpErrorEntry_ExpErrorCode = "divideByZero"
)

type DISMANEXPRESSIONMIB_ExpExpressionTable 

type DISMANEXPRESSIONMIB_ExpExpressionTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Information about a single expression.  New expressions can be created
	// using expExpressionRowStatus.  To create an expression first create the
	// named entry in this table.  Then use expExpressionName to populate
	// expObjectTable. For expression evaluation to succeed all related entries in
	// expExpressionTable and expObjectTable must be 'active'.  If these
	// conditions are not met the corresponding values in expValue simply are not
	// instantiated.  Deleting an entry deletes all related entries in
	// expObjectTable and expErrorTable.  Because of the relationships among the
	// multiple tables for an expression (expExpressionTable, expObjectTable, and
	// expValueTable) and the SNMP rules for independence in setting object
	// values, it is necessary to do final error checking when an expression is
	// evaluated, that is, when one of its instances in expValueTable is read or a
	// delta interval expires.  Earlier checking need not be done and an
	// implementation may not impose any ordering on the creation of objects
	// related to an expression.  To maintain security of MIB information, when
	// creating a new row in this table, the managed system must record the
	// security credentials of the requester.  These security credentials are the
	// parameters necessary as inputs to isAccessAllowed from the Architecture for
	// Describing SNMP Management Frameworks.  When obtaining the objects that
	// make up the expression, the system must (conceptually) use isAccessAllowed
	// to ensure that it does not violate security.  The evaluation of the
	// expression takes place under the security credentials of the creator of its
	// expExpressionEntry.  Values of read-write objects in this table may be
	// changed at any time. The type is slice of
	// DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry.
	ExpExpressionEntry []*DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry
}

DISMANEXPRESSIONMIB_ExpExpressionTable A table of expression definitions.

func (*DISMANEXPRESSIONMIB_ExpExpressionTable) GetEntityData 

func (expExpressionTable *DISMANEXPRESSIONMIB_ExpExpressionTable) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry 

type DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The owner of this entry. The exact semantics of
	// this string are subject to the security policy defined by the security
	// administrator. The type is string with length: 0..32.
	ExpExpressionOwner interface{}

	// This attribute is a key. The name of the expression.  This is locally
	// unique, within the scope of an expExpressionOwner. The type is string with
	// length: 1..32.
	ExpExpressionName interface{}

	// The expression to be evaluated.  This object is the same as a DisplayString
	// (RFC 1903) except for its maximum length.  Except for the variable names
	// the expression is in ANSI C syntax.  Only the subset of ANSI C operators
	// and functions listed here is allowed.  Variables are expressed as a dollar
	// sign ('$') and an integer that corresponds to an expObjectIndex.  An
	// example of a valid expression is:       ($1-$5)*100  Expressions must not
	// be recursive, that is although an expression may use the results of another
	// expression, it must not contain any variable that is directly or indirectly
	// a result of its own evaluation. The managed system must check for recursive
	// expressions.  The only allowed operators are:       ( )      - (unary)
	// + - * / %      & | ^ << >> ~      ! && || == != > >= < <=  Note the
	// parentheses are included for parenthesizing the expression, not for casting
	// data types.  The only constant types defined are:       int (32-bit signed)
	// long (64-bit signed)      unsigned int      unsigned long      hexadecimal
	// character      string      oid  The default type for a positive integer is
	// int unless it is too large in which case it is long.  All but oid are as
	// defined for ANSI C.  Note that a hexadecimal constant may end up as a
	// scalar or an array of 8-bit integers.  A string constant is enclosed in
	// double quotes and may contain back-slashed individual characters as in ANSI
	// C.  An oid constant comprises 32-bit, unsigned integers and at least one
	// period, for example:       0.      .0      1.3.6.1  No additional leading
	// or trailing subidentifiers are automatically added to an OID constant.  The
	// constant is taken as expressed.  Integer-typed objects are treated as 32-
	// or 64-bit, signed or unsigned integers, as appropriate.  The results of
	// mixing them are as for ANSI C, including the type of the result.  Note that
	// a 32-bit value is thus promoted to 64 bits only in an operation with a
	// 64-bit value.  There is no provision for larger values to handle overflow.
	// Relative to SNMP data types, a resulting value becomes unsigned when
	// calculating it uses any unsigned value, including a counter.  To force the
	// final value to be of data type counter the expression must explicitly use
	// the counter32() or counter64() function (defined below).  OCTET STRINGS and
	// OBJECT IDENTIFIERs are treated as one-dimensioned arrays of unsigned 8-bit
	// integers and unsigned 32-bit integers, respectively.  IpAddresses are
	// treated as 32-bit, unsigned integers in network byte order, that is, the
	// hex version of 255.0.0.0 is 0xff000000.  Conditional expressions result in
	// a 32-bit, unsigned integer of value 0 for false or 1 for true. When an
	// arbitrary value is used as a boolean 0 is false and non-zero is true.
	// Rules for the resulting data type from an operation, based on the operator:
	// For << and >> the result is the same as the left hand operand.  For &&, ||,
	// ==, !=, <, <=, >, and >= the result is always Unsigned32.  For unary - the
	// result is always Integer32.  For +, -, *, /, %, &, |, and ^ the result is
	// promoted according to the following rules, in order from most to least
	// preferred:       If left hand and right hand operands are the same type,
	// use that.       If either side is Counter64, use that.       If either side
	// is IpAddress, use that.       If either side is TimeTicks, use that.
	// If either side is Counter32, use that.       Otherwise use Unsigned32.  The
	// following rules say what operators apply with what data types.  Any
	// combination not explicitly defined does not work.  For all operators any of
	// the following can be the left hand or right hand operand: Integer32,
	// Counter32, Unsigned32, Counter64.  The operators +, -, *, /, %, <, <=, >,
	// and >= work with TimeTicks.  The operators &, |, and ^ work with IpAddress.
	// The operators << and >> work with IpAddress but only as the left hand
	// operand.  The + operator performs a concatenation of two OCTET STRINGs or
	// two OBJECT IDENTIFIERs.  The operators &, | perform bitwise operations on
	// OCTET STRINGs. If the OCTET STRING happens to be a DisplayString the
	// results may be meaningless, but the agent system does not check this as
	// some such systems do not have this information.  The operators << and >>
	// perform bitwise operations on OCTET STRINGs appearing as the left hand
	// operand.  The only functions defined are:       counter32      counter64
	// arraySection      stringBegins      stringEnds      stringContains
	// oidBegins      oidEnds      oidContains      average      maximum
	// minimum      sum      exists  The following function definitions indicate
	// their parameters by naming the data type of the parameter in the
	// parameter's position in the parameter list.  The parameter must be of the
	// type indicated and generally may be a constant, a MIB object, a function,
	// or an expression.  counter32(integer) - wrapped around an integer value
	// counter32 forces Counter32 as a data type.  counter64(integer) - similar to
	// counter32 except that the resulting data type is 'counter64'.
	// arraySection(array, integer, integer) - selects a piece of an array (i.e.
	// part of an OCTET STRING or OBJECT IDENTIFIER).  The integer arguments are
	// in the range 0 to 4,294,967,295.  The first is an initial array index
	// (one-dimensioned) and the second is an ending array index.  A value of 0
	// indicates first or last element, respectively.  If the first element is
	// larger than the array length the result is 0 length.  If the second integer
	// is less than or equal to the first, the result is 0 length.  If the second
	// is larger than the array length it indicates last element.
	// stringBegins/Ends/Contains(octetString, octetString) - looks for the second
	// string (which can be a string constant) in the first and returns the
	// one-dimensioned arrayindex where the match began. A return value of 0
	// indicates no match (i.e. boolean false).  oidBegins/Ends/Contains(oid, oid)
	// - looks for the second OID (which can be an OID constant) in the first and
	// returns the the one-dimensioned index where the match began. A return value
	// of 0 indicates no match (i.e. boolean false).
	// average/maximum/minimum(integer) - calculates the average, minimum, or
	// maximum value of the integer valued object over multiple sample times.  If
	// the object disappears for any sample period, the accumulation and the
	// resulting value object cease to exist until the object reappears at which
	// point the calculation starts over.  sum(integerObject*) - sums all
	// available values of the wildcarded integer object, resulting in an integer
	// scalar.  Must be used with caution as it wraps on overflow with no
	// notification.  exists(anyTypeObject) - verifies the object instance exists.
	// A return value of 0 indicates NoSuchInstance (i.e. boolean false). The type
	// is string with length: 1..1024.
	ExpExpression interface{}

	// The type of the expression value.  One and only one of the value objects in
	// expValueTable will be instantiated to match this type.  If the result of
	// the expression can not be made into this type, an invalidOperandType error
	// will occur. The type is ExpExpressionValueType.
	ExpExpressionValueType interface{}

	// A comment to explain the use or meaning of the expression. The type is
	// string.
	ExpExpressionComment interface{}

	// Sampling interval for objects in this expression with expObjectSampleType
	// 'deltaValue'.  This object has no effect if the the expression has no
	// deltaValue objects.  A value of 0 indicates no automated sampling.  In this
	// case the delta is the difference from the last time the expression was
	// evaluated.  Note that this is subject to unpredictable delta times in the
	// face of retries or multiple managers.  A value greater than zero is the
	// number of seconds between automated samples.  Until the delta interval has
	// expired once the delta for the object is effectively not instantiated and
	// evaluating the expression has results as if the object itself were not
	// instantiated.  Note that delta values potentially consume large amounts of
	// system CPU and memory.  Delta state and processing must continue constantly
	// even if the expression is not being used. That is, the expression is being
	// evaluated every delta interval, even if no application is reading those
	// values.  For wildcarded objects this can be substantial overhead.  Note
	// that delta intervals, external expression value sampling intervals and
	// delta intervals for expressions within other expressions can have unusual
	// interactions as they are impossible to synchronize accurately.  In general
	// one interval embedded below another must be enough shorter that the higher
	// sample sees relatively smooth, predictable behavior.  So, for example, to
	// avoid the higher level getting the same sample twice, the lower level
	// should sample at least twice as fast as the higher level does. The type is
	// interface{} with range: 0..86400. Units are seconds.
	ExpExpressionDeltaInterval interface{}

	// An object prefix to assist an application in determining the instance
	// indexing to use in expValueTable, relieving the application of the need to
	// scan the expObjectTable to determine such a prefix.  See expObjectTable for
	// information on wildcarded objects.  If the expValueInstance portion of the
	// value OID may be treated as a scalar (that is, normally, 0) the value of
	// expExpressionPrefix is zero length, that is, no OID at all. Note that zero
	// length implies a null OID, not the OID 0.0.  Otherwise, the value of
	// expExpressionPrefix is the expObjectID value of any one of the wildcarded
	// objects for the expression. This is sufficient, as the remainder, that is,
	// the instance fragment relevant to instancing the values, must be the same
	// for all wildcarded objects in the expression. The type is string with
	// pattern: (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpExpressionPrefix interface{}

	// The number of errors encountered while evaluating this expression.  Note
	// that an object in the expression not being accessible, is not considered an
	// error. An example of an inaccessible object is when the object is excluded
	// from the view of the user whose security credentials are used in the
	// expression evaluation. In such cases, it is a legitimate condition that
	// causes the corresponding expression value not to be instantiated. The type
	// is interface{} with range: 0..4294967295.
	ExpExpressionErrors interface{}

	// The control that allows creation and deletion of entries. The type is
	// RowStatus.
	ExpExpressionEntryStatus interface{}
}

DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry Information about a single expression. New expressions can be created using expExpressionRowStatus.

To create an expression first create the named entry in this table. Then use expExpressionName to populate expObjectTable. For expression evaluation to succeed all related entries in expExpressionTable and expObjectTable must be 'active'. If these conditions are not met the corresponding values in expValue simply are not instantiated.

Deleting an entry deletes all related entries in expObjectTable and expErrorTable.

Because of the relationships among the multiple tables for an expression (expExpressionTable, expObjectTable, and expValueTable) and the SNMP rules for independence in setting object values, it is necessary to do final error checking when an expression is evaluated, that is, when one of its instances in expValueTable is read or a delta interval expires. Earlier checking need not be done and an implementation may not impose any ordering on the creation of objects related to an expression.

To maintain security of MIB information, when creating a new row in this table, the managed system must record the security credentials of the requester. These security credentials are the parameters necessary as inputs to isAccessAllowed from the Architecture for

Describing SNMP Management Frameworks. When obtaining the objects that make up the expression, the system must (conceptually) use isAccessAllowed to ensure that it does not violate security.

The evaluation of the expression takes place under the security credentials of the creator of its expExpressionEntry.

Values of read-write objects in this table may be changed at any time.

func (*DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry) GetEntityData 

func (expExpressionEntry *DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType 

type DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType string

DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType represents an invalidOperandType error will occur. 

const (
	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_counter32 DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "counter32"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_unsigned32 DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "unsigned32"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_timeTicks DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "timeTicks"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_integer32 DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "integer32"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_ipAddress DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "ipAddress"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_octetString DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "octetString"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_objectId DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "objectId"

	DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType_counter64 DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionValueType = "counter64"
)

type DISMANEXPRESSIONMIB_ExpObjectTable 

type DISMANEXPRESSIONMIB_ExpObjectTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// Information about an object.  An application uses expObjectEntryStatus to
	// create entries in this table while in the process of defining an
	// expression.  Values of read-create objects in this table may be changed at
	// any time. The type is slice of
	// DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry.
	ExpObjectEntry []*DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry
}

DISMANEXPRESSIONMIB_ExpObjectTable A table of object definitions for each expExpression.

Wildcarding instance IDs:

It is legal to omit all or part of the instance portion for some or all of the objects in an expression. (See the DESCRIPTION of expObjectID for details. However, note that if more than one object in the same expression is wildcarded in this way, they all must be objects where that portion of the instance is the same. In other words, all objects may be in the same SEQUENCE or in different SEQUENCEs but with the same semantic index value (e.g., a value of ifIndex) for the wildcarded portion.

func (*DISMANEXPRESSIONMIB_ExpObjectTable) GetEntityData 

func (expObjectTable *DISMANEXPRESSIONMIB_ExpObjectTable) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry 

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with length: 0..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionOwner
	ExpExpressionOwner interface{}

	// This attribute is a key. The type is string with length: 1..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionName
	ExpExpressionName interface{}

	// This attribute is a key. Within an expression, a unique, numeric
	// identification for an object.  Prefixed with a dollar sign ('$') this is
	// used to reference the object in the corresponding expExpression. The type
	// is interface{} with range: 1..4294967295.
	ExpObjectIndex interface{}

	// The OBJECT IDENTIFIER (OID) of this object.  The OID may be fully
	// qualified, meaning it includes a complete instance identifier part (e.g.,
	// ifInOctets.1 or sysUpTime.0), or it may not be fully qualified, meaning it
	// may lack all or part of the instance identifier.  If the expObjectID is not
	// fully qualified, then expObjectWildcard must be set to true(1). The value
	// of the expression will be multiple values, as if done for a GetNext sweep
	// of the object.  An object here may itself be the result of an expression
	// but recursion is not allowed.  NOTE:  The simplest implementations of this
	// MIB may not allow wildcards. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpObjectID interface{}

	// A true value indicates the expObjecID of this row is a wildcard object.
	// False indicates that expObjectID is fully instanced. If all
	// expObjectWildcard values for a given expression are FALSE,
	// expExpressionPrefix will reflect a scalar object (i.e. will be 0.0).  NOTE:
	// The simplest implementations of this MIB may not allow wildcards. The type
	// is bool.
	ExpObjectIDWildcard interface{}

	// The method of sampling the selected variable.  An 'absoluteValue' is simply
	// the present value of the object.  A 'deltaValue' is the present value minus
	// the previous value, which was sampled expExpressionDeltaInterval seconds
	// ago. This is intended primarily for use with SNMP counters, which are
	// meaningless as an 'absoluteValue', but may be used with any integer-based
	// value.  A 'changedValue' is a boolean for whether the present value is
	// different from the previous value.  It is applicable to any data type and
	// results in an Unsigned32 with value 1 if the object's value is changed and
	// 0 if not.  In all other respects it is as a 'deltaValue' and all statements
	// and operation regarding delta values apply to changed values.  When an
	// expression contains both delta and absolute values the absolute values are
	// obtained at the end of the delta period. The type is ExpObjectSampleType.
	ExpObjectSampleType interface{}

	// The OBJECT IDENTIFIER (OID) of a TimeTicks, TimeStamp, or DateAndTime
	// object that indicates a discontinuity in the value at expObjectID.  This
	// object is instantiated only if expObjectSampleType is 'deltaValue' or
	// 'changedValue'.  The OID may be for a leaf object (e.g. sysUpTime.0) or may
	// be wildcarded to match expObjectID.  This object supports normal checking
	// for a discontinuity in a counter.  Note that if this object does not point
	// to sysUpTime discontinuity checking must still check sysUpTime for an
	// overall discontinuity.  If the object identified is not accessible no
	// discontinuity check will be made. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpObjectDeltaDiscontinuityID interface{}

	// A true value indicates the expObjectDeltaDiscontinuityID of this row is a
	// wildcard object.  False indicates that expObjectDeltaDiscontinuityID is
	// fully instanced.  This object is instantiated only if expObjectSampleType
	// is 'deltaValue' or 'changedValue'.  NOTE:  The simplest implementations of
	// this MIB may not allow wildcards. The type is bool.
	ExpObjectDiscontinuityIDWildcard interface{}

	// The value 'timeTicks' indicates the expObjectDeltaDiscontinuityID of this
	// row is of syntax TimeTicks.  The value 'timeStamp' indicates syntax
	// TimeStamp.  The value 'dateAndTime indicates syntax DateAndTime.  This
	// object is instantiated only if expObjectSampleType is 'deltaValue' or
	// 'changedValue'. The type is ExpObjectDiscontinuityIDType.
	ExpObjectDiscontinuityIDType interface{}

	// The OBJECT IDENTIFIER (OID) of an object that overrides whether the
	// instance of expObjectID is to be considered usable.  If the value of the
	// object at expObjectConditional is 0 or not instantiated, the object at
	// expObjectID is treated as if it is not instantiated.  In other words,
	// expObjectConditional is a filter that controls whether or not to use the
	// value at expObjectID.  The OID may be for a leaf object (e.g.
	// sysObjectID.0) or may be wildcarded to match expObjectID.  If expObject is
	// wildcarded and expObjectID in the same row is not, the wild portion of
	// expObjectConditional must match the wildcarding of the rest of the
	// expression.  If no object in the expression is wildcarded but
	// expObjectConditional is, use the lexically first instance (if any) of
	// expObjectConditional.  If the value of expObjectConditional is 0.0
	// operation is as if the value pointed to by expObjectConditional is a
	// non-zero (true) value.  Note that expObjectConditional can not trivially
	// use an object of syntax TruthValue, since the underlying value is not 0 or
	// 1. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpObjectConditional interface{}

	// A true value indicates the expObjectConditional of this row is a wildcard
	// object. False indicates that expObjectConditional is fully instanced.
	// NOTE: The simplest implementations of this MIB may not allow wildcards. The
	// type is bool.
	ExpObjectConditionalWildcard interface{}

	// The control that allows creation/deletion of entries.  Objects in this
	// table may be changed while expObjectEntryStatus is in any state. The type
	// is RowStatus.
	ExpObjectEntryStatus interface{}
}

DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry Information about an object. An application uses expObjectEntryStatus to create entries in this table while in the process of defining an expression.

Values of read-create objects in this table may be changed at any time.

func (*DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry) GetEntityData 

func (expObjectEntry *DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType 

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType string

DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType represents 'deltaValue' or 'changedValue'. 

const (
	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType_timeTicks DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType = "timeTicks"

	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType_timeStamp DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType = "timeStamp"

	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType_dateAndTime DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectDiscontinuityIDType = "dateAndTime"
)

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType 

type DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType string

DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType represents period. 

const (
	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType_absoluteValue DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType = "absoluteValue"

	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType_deltaValue DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType = "deltaValue"

	DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType_changedValue DISMANEXPRESSIONMIB_ExpObjectTable_ExpObjectEntry_ExpObjectSampleType = "changedValue"
)

type DISMANEXPRESSIONMIB_ExpResource 

type DISMANEXPRESSIONMIB_ExpResource struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// The minimum expExpressionDeltaInterval this system will accept.  A system
	// may use the larger values of this minimum to lessen the impact of
	// constantly computing deltas.  For larger delta sampling intervals the
	// system samples less often and suffers less overhead.  This object provides
	// a way to enforce such lower overhead for all expressions created after it
	// is set.  The value -1 indicates that expResourceDeltaMinimum is irrelevant
	// as the system will not accept 'deltaValue' as a value for
	// expObjectSampleType.  Unless explicitly resource limited, a system's value
	// for this object should be 1, allowing as small as a 1 second interval for
	// ongoing delta sampling.  Changing this value will not invalidate an
	// existing setting of expObjectSampleType. The type is interface{} with
	// range: -1..-1 | 1..600. Units are seconds.
	ExpResourceDeltaMinimum interface{}

	// For every instance of a deltaValue object, one dynamic instance entry is
	// needed for holding the instance value from the previous sample, i.e. to
	// maintain state.  This object limits maximum number of dynamic instance
	// entries this system will support for wildcarded delta objects in
	// expressions. For a given delta expression, the number of dynamic instances
	// is the number of values that meet all criteria to exist times the number of
	// delta values in the expression.  A value of 0 indicates no preset limit,
	// that is, the limit is dynamic based on system operation and resources.
	// Unless explicitly resource limited, a system's value for this object should
	// be 0.  Changing this value will not eliminate or inhibit existing delta
	// wildcard instance objects but will prevent the creation of more such
	// objects.  An attempt to allocate beyond the limit results in expErrorCode
	// being tooManyWildcardValues for that evaluation attempt. The type is
	// interface{} with range: 0..4294967295. Units are instances.
	ExpResourceDeltaWildcardInstanceMaximum interface{}

	// The number of currently active instance entries as defined for
	// expResourceDeltaWildcardInstanceMaximum. The type is interface{} with
	// range: 0..4294967295. Units are instances.
	ExpResourceDeltaWildcardInstances interface{}

	// The highest value of expResourceDeltaWildcardInstances that has occurred
	// since initialization of the managed system. The type is interface{} with
	// range: 0..4294967295. Units are instances.
	ExpResourceDeltaWildcardInstancesHigh interface{}

	// The number of times this system could not evaluate an expression because
	// that would have created a value instance in excess of
	// expResourceDeltaWildcardInstanceMaximum. The type is interface{} with
	// range: 0..4294967295. Units are instances.
	ExpResourceDeltaWildcardInstanceResourceLacks interface{}
}

DISMANEXPRESSIONMIB_ExpResource

func (*DISMANEXPRESSIONMIB_ExpResource) GetEntityData 

func (expResource *DISMANEXPRESSIONMIB_ExpResource) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpValueTable 

type DISMANEXPRESSIONMIB_ExpValueTable struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter

	// A single value from an evaluated expression.  For a given instance, only
	// one 'Val' object in the conceptual row will be instantiated, that is, the
	// one with the appropriate type for the value.  For values that contain no
	// objects of expObjectSampleType 'deltaValue' or 'changedValue', reading a
	// value from the table causes the evaluation of the expression for that
	// value.  For those that contain a 'deltaValue' or 'changedValue' the value
	// read is as of the last sampling interval.  If in the attempt to evaluate
	// the expression one or more of the necessary objects is not available, the
	// corresponding entry in this table is effectively not instantiated.  To
	// maintain security of MIB information, when creating a new row in this
	// table, the managed system must record the security credentials of the
	// requester.  These security credentials are the parameters necessary as
	// inputs to isAccessAllowed from [RFC2571]. When obtaining the objects that
	// make up the expression, the system must (conceptually) use isAccessAllowed
	// to ensure that it does not violate security.  The evaluation of that
	// expression takes place under the security credentials of the creator of its
	// expExpressionEntry.  To maintain security of MIB information, expression
	// evaluation must take place using security credentials for the implied Gets
	// of the objects in the expression as inputs (conceptually) to
	// isAccessAllowed from the Architecture for Describing SNMP Management
	// Frameworks.  These are the security credentials of the creator of the
	// corresponding expExpressionEntry. The type is slice of
	// DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry.
	ExpValueEntry []*DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry
}

DISMANEXPRESSIONMIB_ExpValueTable A table of values from evaluated expressions.

func (*DISMANEXPRESSIONMIB_ExpValueTable) GetEntityData 

func (expValueTable *DISMANEXPRESSIONMIB_ExpValueTable) GetEntityData() *types.CommonEntityData

type DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry 

type DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry struct {
	EntityData types.CommonEntityData
	YFilter    yfilter.YFilter
	YListKey   string

	// This attribute is a key. The type is string with length: 0..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionOwner
	ExpExpressionOwner interface{}

	// This attribute is a key. The type is string with length: 1..32. Refers to
	// disman_expression_mib.DISMANEXPRESSIONMIB_ExpExpressionTable_ExpExpressionEntry_ExpExpressionName
	ExpExpressionName interface{}

	// This attribute is a key. The final instance portion of a value's OID
	// according to the wildcarding in instances of expObjectID for the
	// expression.  The prefix of this OID fragment is 0.0, leading to the
	// following behavior.  If there is no wildcarding, the value is 0.0.0.  In
	// other words, there is one value which standing alone would have been a
	// scalar with a 0 at the end of its OID.  If there is wildcarding, the value
	// is 0.0 followed by a value that the wildcard can take, thus defining one
	// value instance for each real, possible value of the wildcard. So, for
	// example, if the wildcard worked out to be an ifIndex, there is an
	// expValueInstance for each applicable ifIndex. The type is string with
	// pattern: (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpValueInstance interface{}

	// The value when expExpressionValueType is 'counter32'. The type is
	// interface{} with range: 0..4294967295.
	ExpValueCounter32Val interface{}

	// The value when expExpressionValueType is 'unsigned32'. The type is
	// interface{} with range: 0..4294967295.
	ExpValueUnsigned32Val interface{}

	// The value when expExpressionValueType is 'timeTicks'. The type is
	// interface{} with range: 0..4294967295.
	ExpValueTimeTicksVal interface{}

	// The value when expExpressionValueType is 'integer32'. The type is
	// interface{} with range: -2147483648..2147483647.
	ExpValueInteger32Val interface{}

	// The value when expExpressionValueType is 'ipAddress'. The type is string
	// with pattern:
	// (([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?.
	ExpValueIpAddressVal interface{}

	// The value when expExpressionValueType is 'octetString'. The type is string
	// with length: 0..65536.
	ExpValueOctetStringVal interface{}

	// The value when expExpressionValueType is 'objectId'. The type is string
	// with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	ExpValueOidVal interface{}

	// The value when expExpressionValueType is 'counter64'. The type is
	// interface{} with range: 0..18446744073709551615.
	ExpValueCounter64Val interface{}
}

DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry A single value from an evaluated expression. For a given instance, only one 'Val' object in the conceptual row will be instantiated, that is, the one with the appropriate type for the value. For values that contain no objects of expObjectSampleType 'deltaValue' or 'changedValue', reading a value from the table causes the evaluation of the expression for that value. For those that contain a 'deltaValue' or 'changedValue' the value read is as of the last sampling interval.

If in the attempt to evaluate the expression one or more of the necessary objects is not available, the corresponding entry in this table is effectively not instantiated.

To maintain security of MIB information, when creating a new row in this table, the managed system must record the security credentials of the requester. These security credentials are the parameters necessary as inputs to isAccessAllowed from [RFC2571]. When obtaining the objects that make up the expression, the system must (conceptually) use isAccessAllowed to ensure that it does not violate security.

The evaluation of that expression takes place under the security credentials of the creator of its expExpressionEntry.

To maintain security of MIB information, expression evaluation must take place using security credentials for the implied Gets of the objects in the expression as inputs (conceptually) to isAccessAllowed from the Architecture for Describing SNMP Management Frameworks. These are the security credentials of the creator of the corresponding expExpressionEntry.

func (*DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry) GetEntityData 

func (expValueEntry *DISMANEXPRESSIONMIB_ExpValueTable_ExpValueEntry) GetEntityData() *types.CommonEntityData

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.