diffserv_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

This MIB defines the objects necessary to manage a device that uses the Differentiated Services Architecture described in RFC 2475. The Conceptual Model of a Differentiated Services Router provides supporting information on how such a router is modeled.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DIFFSERVMIB 

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

	DiffServClassifier DIFFSERVMIB_DiffServClassifier

	DiffServMeter DIFFSERVMIB_DiffServMeter

	DiffServTBParam DIFFSERVMIB_DiffServTBParam

	DiffServAction DIFFSERVMIB_DiffServAction

	DiffServAlgDrop DIFFSERVMIB_DiffServAlgDrop

	DiffServQueue DIFFSERVMIB_DiffServQueue

	DiffServScheduler DIFFSERVMIB_DiffServScheduler

	// The data path table contains RowPointers indicating the start of the
	// functional data path for each interface and traffic direction in this
	// device. These may merge, or be separated into parallel data paths.
	DiffServDataPathTable DIFFSERVMIB_DiffServDataPathTable

	// This table enumerates all the diffserv classifier functional data path
	// elements of this device.  The actual classification definitions are defined
	// in diffServClfrElementTable entries belonging to each classifier.  An entry
	// in this table, pointed to by a RowPointer specifying an instance of
	// diffServClfrStatus, is frequently used as the name for a set of classifier
	// elements, which all use the index diffServClfrId. Per the semantics of the
	// classifier element table, these entries constitute one or more unordered
	// sets of tests which may be simultaneously applied to a message to
	// classify it.  The primary function of this table is to ensure that the
	// value of diffServClfrId is unique before attempting to use it in creating a
	// diffServClfrElementEntry. Therefore, the diffServClfrEntry must be created
	// on the same SET as the diffServClfrElementEntry, or before the
	// diffServClfrElementEntry is created.
	DiffServClfrTable DIFFSERVMIB_DiffServClfrTable

	// The classifier element table enumerates the relationship between
	// classification patterns and subsequent downstream Differentiated Services
	// Functional Data Path elements. diffServClfrElementSpecific points to a
	// filter that specifies the classification parameters. A classifier may use
	// filter tables of different types together.  One example of a filter table
	// defined in this MIB is diffServMultiFieldClfrTable, for IP Multi-Field
	// Classifiers (MFCs). Such an entry might identify anything from a single
	// micro-flow (an identifiable sub-session packet stream directed from one
	// sending transport to the receiving transport or transports), or aggregates
	// of those such as the traffic from a host, traffic for an application, or
	// traffic between two hosts using an application and a given DSCP. The
	// standard Behavior Aggregate used in the Differentiated Services
	// Architecture is encoded as a degenerate case of such an aggregate - the
	// traffic using a particular DSCP value.  Filter tables for other filter
	// types may be defined elsewhere.
	DiffServClfrElementTable DIFFSERVMIB_DiffServClfrElementTable

	// A table of IP Multi-field Classifier filter entries that a    system may
	// use to identify IP traffic.
	DiffServMultiFieldClfrTable DIFFSERVMIB_DiffServMultiFieldClfrTable

	// This table enumerates specific meters that a system may use to police a
	// stream of traffic. The traffic stream to be metered is determined by the
	// Differentiated Services Functional Data Path Element(s) upstream of the
	// meter i.e. by the object(s) that point to each entry in this table.  This
	// may include all traffic on an interface.  Specific meter details are to be
	// found in table entry referenced by diffServMeterSpecific.
	DiffServMeterTable DIFFSERVMIB_DiffServMeterTable

	// This table enumerates a single set of token bucket meter parameters that a
	// system may use to police a stream of traffic. Such meters are modeled here
	// as having a single rate and a single burst size. Multiple entries are used
	// when multiple rates/burst sizes are needed.
	DiffServTBParamTable DIFFSERVMIB_DiffServTBParamTable

	// The Action Table enumerates actions that can be performed to a stream of
	// traffic. Multiple actions can be concatenated. For example, traffic exiting
	// from a meter may be counted, marked, and potentially dropped before
	// entering a queue.  Specific actions are indicated by diffServActionSpecific
	// which points to an entry of a specific action type parameterizing the
	// action in detail.
	DiffServActionTable DIFFSERVMIB_DiffServActionTable

	// This table enumerates specific DSCPs used for marking or remarking the DSCP
	// field of IP packets. The entries of this table may be referenced by a
	// diffServActionSpecific attribute.
	DiffServDscpMarkActTable DIFFSERVMIB_DiffServDscpMarkActTable

	// This table contains counters for all the traffic passing through an action
	// element.
	DiffServCountActTable DIFFSERVMIB_DiffServCountActTable

	// The algorithmic drop table contains entries describing an element that
	// drops packets according to some algorithm.
	DiffServAlgDropTable DIFFSERVMIB_DiffServAlgDropTable

	// The random drop table contains entries describing a process that drops
	// packets randomly. Entries in this table are pointed to by
	// diffServAlgDropSpecific.
	DiffServRandomDropTable DIFFSERVMIB_DiffServRandomDropTable

	// The Queue Table enumerates the individual queues.  Note that the MIB models
	// queuing systems as composed of individual queues, one per class of traffic,
	// even though they may in fact be structured as classes of traffic scheduled
	// using a common calendar queue, or in other ways.
	DiffServQTable DIFFSERVMIB_DiffServQTable

	// The Scheduler Table enumerates packet schedulers. Multiple scheduling
	// algorithms can be used on a given data path, with each algorithm described
	// by one diffServSchedulerEntry.
	DiffServSchedulerTable DIFFSERVMIB_DiffServSchedulerTable

	// The Minimum Rate Parameters Table enumerates individual sets of scheduling
	// parameter that can be used/reused by Queues and Schedulers.
	DiffServMinRateTable DIFFSERVMIB_DiffServMinRateTable

	// The Maximum Rate Parameter Table enumerates individual sets of scheduling
	// parameter that can be used/reused by Queues and Schedulers.
	DiffServMaxRateTable DIFFSERVMIB_DiffServMaxRateTable
}

DIFFSERVMIB

func (*DIFFSERVMIB) GetEntityData 

func (dIFFSERVMIB *DIFFSERVMIB) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServAction 

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

	// This object contains an unused value for diffServActionId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServActionNextFree interface{}

	// This object contains an unused value for diffServCountActId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServCountActNextFree interface{}
}

DIFFSERVMIB_DiffServAction

func (*DIFFSERVMIB_DiffServAction) GetEntityData 

func (diffServAction *DIFFSERVMIB_DiffServAction) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServActionTable 

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

	// Each entry in the action table allows description of one specific action to
	// be applied to traffic. The type is slice of
	// DIFFSERVMIB_DiffServActionTable_DiffServActionEntry.
	DiffServActionEntry []*DIFFSERVMIB_DiffServActionTable_DiffServActionEntry
}

DIFFSERVMIB_DiffServActionTable The Action Table enumerates actions that can be performed to a stream of traffic. Multiple actions can be concatenated. For example, traffic exiting from a meter may be counted, marked, and potentially dropped before entering a queue.

Specific actions are indicated by diffServActionSpecific which points to an entry of a specific action type parameterizing the action in detail.

func (*DIFFSERVMIB_DiffServActionTable) GetEntityData 

func (diffServActionTable *DIFFSERVMIB_DiffServActionTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServActionTable_DiffServActionEntry 

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

	// This attribute is a key. An index that enumerates the Action entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServActionNextFree. The type is interface{} with range: 1..4294967295.
	DiffServActionId interface{}

	// The interface index (value of ifIndex) that this action occurs on. This may
	// be derived from the diffServDataPathStartEntry's index by extension through
	// the various RowPointers. However, as this may be difficult for a network
	// management station, it is placed here as well.  If this is indeterminate,
	// the value is zero.  This is of especial relevance when reporting the
	// counters which may apply to traffic crossing an interface:
	// diffServCountActOctets,    diffServCountActPkts,    diffServAlgDropOctets,
	// diffServAlgDropPkts,    diffServAlgRandomDropOctets, and
	// diffServAlgRandomDropPkts.  It is also especially relevant to the queue and
	// scheduler which may be subsequently applied. The type is interface{} with
	// range: 0..2147483647.
	DiffServActionInterface interface{}

	// This selects the next Differentiated Services Functional Data Path Element
	// to handle traffic for this data path. This RowPointer should point to an
	// instance of one of:   diffServClfrEntry   diffServMeterEntry
	// diffServActionEntry   diffServAlgDropEntry   diffServQEntry  A value of
	// zeroDotZero in this attribute indicates no further Differentiated Services
	// treatment is performed on traffic of this data path. The use of zeroDotZero
	// is the normal usage for the last functional data path element of the
	// current data path.  Setting this to point to a target that does not exist
	// results in an inconsistentValue error.  If the row pointed to is removed or
	// becomes inactive by other means, the treatment is as if this attribute
	// contains a value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServActionNext interface{}

	// A pointer to an object instance providing additional information for the
	// type of action indicated by this action table entry.  For the standard
	// actions defined by this MIB module, this should point to either a
	// diffServDscpMarkActEntry or a diffServCountActEntry. For other actions, it
	// may point to an object instance defined in some other MIB.  Setting this to
	// point to a target that does not exist results in an inconsistentValue
	// error.  If the row pointed to is removed or becomes inactive by other
	// means, the Meter should be treated as if it were not present.  This may
	// lead to incorrect policy behavior. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServActionSpecific interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServActionStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServActionStatus interface{}
}

DIFFSERVMIB_DiffServActionTable_DiffServActionEntry Each entry in the action table allows description of one specific action to be applied to traffic.

func (*DIFFSERVMIB_DiffServActionTable_DiffServActionEntry) GetEntityData 

func (diffServActionEntry *DIFFSERVMIB_DiffServActionTable_DiffServActionEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServAlgDrop 

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

	// This object contains an unused value for diffServAlgDropId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServAlgDropNextFree interface{}

	// This object contains an unused value for diffServRandomDropId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServRandomDropNextFree interface{}
}

DIFFSERVMIB_DiffServAlgDrop

func (*DIFFSERVMIB_DiffServAlgDrop) GetEntityData 

func (diffServAlgDrop *DIFFSERVMIB_DiffServAlgDrop) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServAlgDropTable 

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

	// An entry describes a process that drops packets according to some
	// algorithm. Further details of the algorithm type are to be found in
	// diffServAlgDropType and with more detail parameter entry pointed to by
	// diffServAlgDropSpecific when necessary. The type is slice of
	// DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry.
	DiffServAlgDropEntry []*DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry
}

DIFFSERVMIB_DiffServAlgDropTable The algorithmic drop table contains entries describing an element that drops packets according to some algorithm.

func (*DIFFSERVMIB_DiffServAlgDropTable) GetEntityData 

func (diffServAlgDropTable *DIFFSERVMIB_DiffServAlgDropTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry 

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

	// This attribute is a key. An index that enumerates the Algorithmic Dropper
	// entries. Managers obtain new values for row creation in this table by
	// reading diffServAlgDropNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServAlgDropId interface{}

	// The type of algorithm used by this dropper. The value other(1) requires
	// further specification in some other MIB module.  In the tailDrop(2)
	// algorithm, diffServAlgDropQThreshold represents the maximum depth of the
	// queue, pointed to by diffServAlgDropQMeasure, beyond which all newly
	// arriving packets will be dropped.  In the headDrop(3) algorithm, if a
	// packet arrives when the current depth of the queue, pointed to by
	// diffServAlgDropQMeasure, is at diffServAlgDropQThreshold, packets currently
	// at the head of the queue are dropped to make room for the new packet to be
	// enqueued at the tail of the queue.  In the randomDrop(4) algorithm, on
	// packet arrival, an Active Queue Management algorithm is executed which may
	// randomly drop a packet. This algorithm may be proprietary, and it may drop
	// either the arriving packet or another packet in the queue.
	// diffServAlgDropSpecific points to a diffServRandomDropEntry that describes
	// the algorithm. For this algorithm,    diffServAlgDropQThreshold is
	// understood to be the absolute maximum size of the queue and additional
	// parameters are described in diffServRandomDropTable.  The alwaysDrop(5)
	// algorithm is as its name specifies; always drop. In this case, the other
	// configuration values in this Entry are not meaningful; There is no useful
	// 'next' processing step, there is no queue, and parameters describing the
	// queue are not useful. Therefore, diffServAlgDropNext,
	// diffServAlgDropMeasure, and diffServAlgDropSpecific are all zeroDotZero.
	// The type is DiffServAlgDropType.
	DiffServAlgDropType interface{}

	// This selects the next Differentiated Services Functional Data Path Element
	// to handle traffic for this data path. This RowPointer should point to an
	// instance of one of:   diffServClfrEntry   diffServMeterEntry
	// diffServActionEntry   diffServQEntry  A value of zeroDotZero in this
	// attribute indicates no further Differentiated Services treatment is
	// performed on traffic of this data path. The use of zeroDotZero is the
	// normal usage for the last functional data path element of the current data
	// path.  When diffServAlgDropType is alwaysDrop(5), this object is ignored.
	// Setting this to point to a target that does not exist results in an
	// inconsistentValue error.  If the row pointed to is removed or becomes
	// inactive by other means, the treatment is as if this attribute contains a
	// value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServAlgDropNext interface{}

	// Points to an entry in the diffServQTable to indicate the queue that a drop
	// algorithm is to monitor when deciding whether to drop a packet. If the row
	// pointed to does not exist, the algorithmic dropper element is considered
	// inactive.    Setting this to point to a target that does not exist results
	// in an inconsistentValue error.  If the row pointed to is removed or becomes
	// inactive by other means, the treatment is as if this attribute contains a
	// value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServAlgDropQMeasure interface{}

	// A threshold on the depth in bytes of the queue being measured at which a
	// trigger is generated to the dropping algorithm, unless diffServAlgDropType
	// is alwaysDrop(5) where this object is ignored.  For the tailDrop(2) or
	// headDrop(3) algorithms, this represents the depth of the queue, pointed to
	// by diffServAlgDropQMeasure, at which the drop action will take place. Other
	// algorithms will need to define their own semantics for this threshold. The
	// type is interface{} with range: 1..4294967295. Units are Bytes.
	DiffServAlgDropQThreshold interface{}

	// Points to a table entry that provides further detail regarding a drop
	// algorithm.  Entries with diffServAlgDropType equal to other(1) may have
	// this point to a table defined in another MIB module.  Entries with
	// diffServAlgDropType equal to randomDrop(4) must have this point to an entry
	// in diffServRandomDropTable.  For all other algorithms specified in this
	// MIB, this should take the value zeroDotZero.  The diffServAlgDropType is
	// authoritative for the type of the drop algorithm and the specific
	// parameters for the drop algorithm needs to be evaluated based on the
	// diffServAlgDropType.  Setting this to point to a target that does not exist
	// results in an inconsistentValue error.  If the row pointed to is removed or
	// becomes inactive by other means, the treatment is as if this attribute
	// contains a value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServAlgDropSpecific interface{}

	// The number of octets that have been deterministically dropped by this drop
	// process.  Discontinuities in the value of this counter can occur at re-
	// initialization of the management system and at other times as indicated by
	// the value of ifCounterDiscontinuityTime on the relevant interface. The type
	// is interface{} with range: 0..18446744073709551615.
	DiffServAlgDropOctets interface{}

	// The number of packets that have been deterministically dropped by this drop
	// process.  Discontinuities in the value of this counter can occur at re-
	// initialization of the management system and at other times as indicated by
	// the value of ifCounterDiscontinuityTime on the relevant interface. The type
	// is interface{} with range: 0..18446744073709551615.
	DiffServAlgDropPkts interface{}

	// The number of octets that have been randomly dropped by this drop process.
	// This counter applies, therefore, only to random droppers.  Discontinuities
	// in the value of this counter can occur at re- initialization of the
	// management system and at other times as indicated by the value of
	// ifCounterDiscontinuityTime on the relevant interface. The type is
	// interface{} with range: 0..18446744073709551615.
	DiffServAlgRandomDropOctets interface{}

	// The number of packets that have been randomly dropped by this drop process.
	// This counter applies, therefore, only to random droppers.  Discontinuities
	// in the value of this counter can occur at re- initialization of the
	// management system and at other times as indicated by the value of
	// ifCounterDiscontinuityTime on the relevant interface. The type is
	// interface{} with range: 0..18446744073709551615.
	DiffServAlgRandomDropPkts interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServAlgDropStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServAlgDropStatus interface{}
}

DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry An entry describes a process that drops packets according to some algorithm. Further details of the algorithm type are to be found in diffServAlgDropType and with more detail parameter entry pointed to by diffServAlgDropSpecific when necessary.

func (*DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry) GetEntityData 

func (diffServAlgDropEntry *DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType 

type DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType string

DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType represents and diffServAlgDropSpecific are all zeroDotZero. 

const (
	DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType_other DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType = "other"

	DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType_tailDrop DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType = "tailDrop"

	DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType_headDrop DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType = "headDrop"

	DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType_randomDrop DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType = "randomDrop"

	DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType_alwaysDrop DIFFSERVMIB_DiffServAlgDropTable_DiffServAlgDropEntry_DiffServAlgDropType = "alwaysDrop"
)

type DIFFSERVMIB_DiffServClassifier 

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

	// This object contains an unused value for diffServClfrId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServClfrNextFree interface{}

	// This object contains an unused value for diffServClfrElementId, or a zero
	// to indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServClfrElementNextFree interface{}

	// This object contains an unused value for diffServMultiFieldClfrId, or a
	// zero to indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServMultiFieldClfrNextFree interface{}
}

DIFFSERVMIB_DiffServClassifier

func (*DIFFSERVMIB_DiffServClassifier) GetEntityData 

func (diffServClassifier *DIFFSERVMIB_DiffServClassifier) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServClfrElementTable 

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

	// An entry in the classifier element table describes a single element of the
	// classifier. The type is slice of
	// DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry.
	DiffServClfrElementEntry []*DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry
}

DIFFSERVMIB_DiffServClfrElementTable The classifier element table enumerates the relationship between classification patterns and subsequent downstream Differentiated Services Functional Data Path elements. diffServClfrElementSpecific points to a filter that specifies the classification parameters. A classifier may use filter tables of different types together.

One example of a filter table defined in this MIB is diffServMultiFieldClfrTable, for IP Multi-Field Classifiers (MFCs). Such an entry might identify anything from a single micro-flow (an identifiable sub-session packet stream directed from one sending transport to the receiving transport or transports), or aggregates of those such as the traffic from a host, traffic for an application, or traffic between two hosts using an application and a given DSCP. The standard Behavior Aggregate used in the Differentiated Services Architecture is encoded as a degenerate case of such an aggregate - the traffic using a particular DSCP value.

Filter tables for other filter types may be defined elsewhere.

func (*DIFFSERVMIB_DiffServClfrElementTable) GetEntityData 

func (diffServClfrElementTable *DIFFSERVMIB_DiffServClfrElementTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry 

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

	// This attribute is a key. The type is string with range: 1..4294967295.
	// Refers to
	// diffserv_mib.DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry_DiffServClfrId
	DiffServClfrId interface{}

	// This attribute is a key. An index that enumerates the Classifier Element
	// entries. Managers obtain new values for row creation in this table by
	// reading diffServClfrElementNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServClfrElementId interface{}

	// The relative order in which classifier elements are applied: higher numbers
	// represent classifier element with higher precedence.  Classifier elements
	// with the same order must be unambiguous i.e. they must define
	// non-overlapping patterns, and are considered to be applied simultaneously
	// to the traffic stream. Classifier elements with different order may overlap
	// in their filters:  the classifier element with the highest order that
	// matches is taken.  On a given interface, there must be a complete
	// classifier in place at all times in the ingress direction.  This means one
	// or more filters must match any possible pattern. There is no such
	// requirement in the egress direction. The type is interface{} with range:
	// 1..4294967295.
	DiffServClfrElementPrecedence interface{}

	// This attribute provides one branch of the fan-out functionality of a
	// classifier described in the Informal Differentiated Services Model section
	// 4.1.  This selects the next Differentiated Services Functional Data Path
	// Element to handle traffic for this data path. This RowPointer should point
	// to an instance of one of:   diffServClfrEntry   diffServMeterEntry
	// diffServActionEntry   diffServAlgDropEntry   diffServQEntry  A value of
	// zeroDotZero in this attribute indicates no further Differentiated Services
	// treatment is performed on traffic of this data path. The use of zeroDotZero
	// is the normal usage for the last functional data path element of the
	// current data path.  Setting this to point to a target that does not exist
	// results in an inconsistentValue error.  If the row pointed to is removed or
	// becomes inactive by other means, the treatment is as if this attribute
	// contains a value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServClfrElementNext interface{}

	// A pointer to a valid entry in another table, filter table, that describes
	// the applicable classification parameters, e.g. an entry in
	// diffServMultiFieldClfrTable.  The value zeroDotZero is interpreted to match
	// anything not matched by another classifier element - only one such entry
	// may exist for each classifier.  Setting this to point to a target that does
	// not exist results in an inconsistentValue error.  If the row pointed to is
	// removed or    becomes inactive by other means, the element is ignored. The
	// type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServClfrElementSpecific interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServClfrElementStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServClfrElementStatus interface{}
}

DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry An entry in the classifier element table describes a single element of the classifier.

func (*DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry) GetEntityData 

func (diffServClfrElementEntry *DIFFSERVMIB_DiffServClfrElementTable_DiffServClfrElementEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServClfrTable 

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

	// An entry in the classifier table describes a single classifier. All
	// classifier elements belonging to the same classifier use the classifier's
	// diffServClfrId as part of their index. The type is slice of
	// DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry.
	DiffServClfrEntry []*DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry
}

DIFFSERVMIB_DiffServClfrTable This table enumerates all the diffserv classifier functional data path elements of this device. The actual classification definitions are defined in diffServClfrElementTable entries belonging to each classifier.

An entry in this table, pointed to by a RowPointer specifying an instance of diffServClfrStatus, is frequently used as the name for a set of classifier elements, which all use the index diffServClfrId. Per the semantics of the classifier element table, these entries constitute one or more unordered sets of tests which may be simultaneously applied to a message to

classify it.

The primary function of this table is to ensure that the value of diffServClfrId is unique before attempting to use it in creating a diffServClfrElementEntry. Therefore, the diffServClfrEntry must be created on the same SET as the diffServClfrElementEntry, or before the diffServClfrElementEntry is created.

func (*DIFFSERVMIB_DiffServClfrTable) GetEntityData 

func (diffServClfrTable *DIFFSERVMIB_DiffServClfrTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry 

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

	// This attribute is a key. An index that enumerates the classifier entries.
	// Managers should obtain new values for row creation in this table by reading
	// diffServClfrNextFree. The type is interface{} with range: 1..4294967295.
	DiffServClfrId interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServClfrStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServClfrStatus interface{}
}

DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry An entry in the classifier table describes a single classifier. All classifier elements belonging to the same classifier use the classifier's diffServClfrId as part of their index.

func (*DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry) GetEntityData 

func (diffServClfrEntry *DIFFSERVMIB_DiffServClfrTable_DiffServClfrEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServCountActTable 

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

	// An entry in the count action table describes a single set of traffic
	// counters. The type is slice of
	// DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry.
	DiffServCountActEntry []*DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry
}

DIFFSERVMIB_DiffServCountActTable This table contains counters for all the traffic passing through an action element.

func (*DIFFSERVMIB_DiffServCountActTable) GetEntityData 

func (diffServCountActTable *DIFFSERVMIB_DiffServCountActTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry 

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

	// This attribute is a key. An index that enumerates the Count Action entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServCountActNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServCountActId interface{}

	// The number of octets at the Action data path element.  Discontinuities in
	// the value of this counter can occur at re- initialization of the management
	// system and at other times as indicated by the value of
	// ifCounterDiscontinuityTime on the relevant interface. The type is
	// interface{} with range: 0..18446744073709551615.
	DiffServCountActOctets interface{}

	// The number of packets at the Action data path element.  Discontinuities in
	// the value of this counter can occur at re- initialization of the management
	// system and at other times as indicated by the value of
	// ifCounterDiscontinuityTime on the relevant interface. The type is
	// interface{} with range: 0..18446744073709551615.
	DiffServCountActPkts interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServCountActStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing    to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServCountActStatus interface{}
}

DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry An entry in the count action table describes a single set of traffic counters.

func (*DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry) GetEntityData 

func (diffServCountActEntry *DIFFSERVMIB_DiffServCountActTable_DiffServCountActEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServDataPathTable 

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

	// An entry in the data path table indicates the start of a single
	// Differentiated Services Functional Data Path in this device.  These are
	// associated with individual interfaces, logical or physical, and therefore
	// are instantiated by ifIndex. Therefore, the interface index must have been
	// assigned, according to the procedures applicable to that, before it can be
	// meaningfully used. Generally, this means that the interface must exist.
	// When diffServDataPathStorage is of type nonVolatile, however, this may
	// reflect the configuration for an interface whose ifIndex has been assigned
	// but for which the supporting implementation is not currently present. The
	// type is slice of DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry.
	DiffServDataPathEntry []*DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry
}

DIFFSERVMIB_DiffServDataPathTable The data path table contains RowPointers indicating the start of the functional data path for each interface and traffic direction in this device. These may merge, or be separated into parallel data paths.

func (*DIFFSERVMIB_DiffServDataPathTable) GetEntityData 

func (diffServDataPathTable *DIFFSERVMIB_DiffServDataPathTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry 

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

	// This attribute is a key. The type is string with range: 1..2147483647.
	// Refers to if_mib.IFMIB_IfTable_IfEntry_IfIndex
	IfIndex interface{}

	// This attribute is a key. IfDirection specifies whether the reception or
	// transmission path for this interface is in view. The type is IfDirection.
	DiffServDataPathIfDirection interface{}

	// This selects the first Differentiated Services Functional Data Path Element
	// to handle traffic for this data path. This RowPointer should point to an
	// instance of one of:   diffServClfrEntry   diffServMeterEntry
	// diffServActionEntry   diffServAlgDropEntry   diffServQEntry  A value of
	// zeroDotZero in this attribute indicates that no Differentiated Services
	// treatment is performed on traffic of this data path. A pointer with the
	// value zeroDotZero normally terminates a functional data path.  Setting this
	// to point to a target that does not exist results in an inconsistentValue
	// error.  If the row pointed to is removed or becomes inactive by other
	// means, the treatment is as if this attribute contains a value of
	// zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServDataPathStart interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServDataPathStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. The type is RowStatus.
	DiffServDataPathStatus interface{}
}

DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry An entry in the data path table indicates the start of a single Differentiated Services Functional Data Path in this device.

These are associated with individual interfaces, logical or physical, and therefore are instantiated by ifIndex. Therefore, the interface index must have been assigned, according to the procedures applicable to that, before it can be meaningfully used. Generally, this means that the interface must exist.

When diffServDataPathStorage is of type nonVolatile, however, this may reflect the configuration for an interface whose ifIndex has been assigned but for which the supporting implementation is not currently present.

func (*DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry) GetEntityData 

func (diffServDataPathEntry *DIFFSERVMIB_DiffServDataPathTable_DiffServDataPathEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServDscpMarkActTable 

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

	// An entry in the DSCP mark action table that describes a single DSCP used
	// for marking. The type is slice of
	// DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry.
	DiffServDscpMarkActEntry []*DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry
}

DIFFSERVMIB_DiffServDscpMarkActTable This table enumerates specific DSCPs used for marking or remarking the DSCP field of IP packets. The entries of this table may be referenced by a diffServActionSpecific attribute.

func (*DIFFSERVMIB_DiffServDscpMarkActTable) GetEntityData 

func (diffServDscpMarkActTable *DIFFSERVMIB_DiffServDscpMarkActTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry 

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

	// This attribute is a key. The DSCP that this Action will store into the DSCP
	// field of the subject. It is quite possible that the only packets subject to
	// this Action are already marked with this DSCP. Note also that
	// Differentiated Services processing may result in packet being marked on
	// both ingress to a network and on egress from it, and that ingress and
	// egress can occur in the same router. The type is interface{} with range:
	// 0..63.
	DiffServDscpMarkActDscp interface{}
}

DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry An entry in the DSCP mark action table that describes a single DSCP used for marking.

func (*DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry) GetEntityData 

func (diffServDscpMarkActEntry *DIFFSERVMIB_DiffServDscpMarkActTable_DiffServDscpMarkActEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMaxRateTable 

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

	// An entry in the Maximum Rate Parameter Table describes a single set of
	// scheduling parameters for use by one or more queues or schedulers. The type
	// is slice of DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry.
	DiffServMaxRateEntry []*DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry
}

DIFFSERVMIB_DiffServMaxRateTable The Maximum Rate Parameter Table enumerates individual sets of scheduling parameter that can be used/reused by Queues and Schedulers.

func (*DIFFSERVMIB_DiffServMaxRateTable) GetEntityData 

func (diffServMaxRateTable *DIFFSERVMIB_DiffServMaxRateTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry 

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

	// This attribute is a key. An index that enumerates the Maximum Rate
	// Parameter entries. Managers obtain new values for row creation in this
	// table by reading diffServMaxRateNextFree. The type is interface{} with
	// range: 1..4294967295.
	DiffServMaxRateId interface{}

	// This attribute is a key. An index that indicates which level of a
	// multi-rate shaper is being given its parameters. A multi-rate shaper has
	// some number of rate levels. Frame Relay's dual rate specification refers to
	// a 'committed' and an 'excess' rate; ATM's dual rate specification refers to
	// a 'mean' and a 'peak' rate. This table is generalized to support an
	// arbitrary number of rates. The committed or mean rate is level 1, the peak
	// rate (if any) is the highest level rate configured, and if there are other
	// rates they are distributed in monotonically increasing order between them.
	// The type is interface{} with range: 1..32.
	DiffServMaxRateLevel interface{}

	// The maximum rate in kilobits/sec that a downstream scheduler element should
	// allocate to this queue. If the value is zero, then there is effectively no
	// maximum rate limit and that the scheduler should attempt to be work
	// conserving for this queue. If the value is non-zero, the scheduler will
	// limit the servicing of this queue to, at most, this rate in a
	// non-work-conserving manner.  Note that this attribute value and that of
	// diffServMaxRateRelative are coupled: changes to one will affect the value
	// of the other. They are linked by the following    equation, in that setting
	// one will change the other:    diffServMaxRateRelative =
	// (diffServMaxRateAbsolute*1000000)/ifSpeed  or, if appropriate:
	// diffServMaxRateRelative = diffServMaxRateAbsolute/ifHighSpeed. The type is
	// interface{} with range: 1..4294967295. Units are kilobits per second.
	DiffServMaxRateAbsolute interface{}

	// The maximum rate that a downstream scheduler element should allocate to
	// this queue, relative to the maximum rate of the interface as reported by
	// ifSpeed or ifHighSpeed, in units of 1/1000 of 1. If the value is zero, then
	// there is effectively no maximum rate limit and the scheduler should attempt
	// to be work conserving for this queue. If the value is non-zero, the
	// scheduler will limit the servicing of this queue to, at most, this rate in
	// a non-work-conserving manner.  Note that this attribute value and that of
	// diffServMaxRateAbsolute are coupled: changes to one will affect the value
	// of the other. They are linked by the following equation, in that setting
	// one will change the other:    diffServMaxRateRelative =
	// (diffServMaxRateAbsolute*1000000)/ifSpeed  or, if appropriate:
	// diffServMaxRateRelative = diffServMaxRateAbsolute/ifHighSpeed. The type is
	// interface{} with range: 1..4294967295.
	DiffServMaxRateRelative interface{}

	// The number of bytes of queue depth at which the rate of a    multi-rate
	// scheduler will increase to the next output rate. In the last conceptual row
	// for such a shaper, this threshold is ignored and by convention is zero. The
	// type is interface{} with range: 0..2147483647. Units are Bytes.
	DiffServMaxRateThreshold interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServMaxRateStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServMaxRateStatus interface{}
}

DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry An entry in the Maximum Rate Parameter Table describes a single set of scheduling parameters for use by one or more queues or schedulers.

func (*DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry) GetEntityData 

func (diffServMaxRateEntry *DIFFSERVMIB_DiffServMaxRateTable_DiffServMaxRateEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMeter 

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

	// This object contains an unused value for diffServMeterId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServMeterNextFree interface{}
}

DIFFSERVMIB_DiffServMeter

func (*DIFFSERVMIB_DiffServMeter) GetEntityData 

func (diffServMeter *DIFFSERVMIB_DiffServMeter) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMeterTable 

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

	// An entry in the meter table describes a single conformance level of a
	// meter. The type is slice of
	// DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry.
	DiffServMeterEntry []*DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry
}

DIFFSERVMIB_DiffServMeterTable This table enumerates specific meters that a system may use to police a stream of traffic. The traffic stream to be metered is determined by the Differentiated Services Functional Data Path Element(s) upstream of the meter i.e. by the object(s) that point to each entry in this table. This may include all traffic on an interface.

Specific meter details are to be found in table entry referenced by diffServMeterSpecific.

func (*DIFFSERVMIB_DiffServMeterTable) GetEntityData 

func (diffServMeterTable *DIFFSERVMIB_DiffServMeterTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry 

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

	// This attribute is a key. An index that enumerates the Meter entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServMeterNextFree. The type is interface{} with range: 1..4294967295.
	DiffServMeterId interface{}

	// If the traffic does conform, this selects the next Differentiated Services
	// Functional Data Path element to handle traffic for this data path. This
	// RowPointer should point to an instance of one of:   diffServClfrEntry
	// diffServMeterEntry   diffServActionEntry   diffServAlgDropEntry
	// diffServQEntry  A value of zeroDotZero in this attribute indicates that no
	// further Differentiated Services treatment is performed on traffic of this
	// data path. The use of zeroDotZero is the normal usage for the last
	// functional data path element of the current data path.  Setting this to
	// point to a target that does not exist results in an inconsistentValue
	// error.  If the row pointed to is removed or becomes inactive by other
	// means, the treatment is as if this attribute contains a value of
	// zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServMeterSucceedNext interface{}

	// If the traffic does not conform, this selects the next Differentiated
	// Services Functional Data Path element to handle traffic for this data path.
	// This RowPointer should point to an instance of one of:   diffServClfrEntry
	// diffServMeterEntry      diffServActionEntry   diffServAlgDropEntry
	// diffServQEntry  A value of zeroDotZero in this attribute indicates no
	// further Differentiated Services treatment is performed on traffic of this
	// data path. The use of zeroDotZero is the normal usage for the last
	// functional data path element of the current data path.  Setting this to
	// point to a target that does not exist results in an inconsistentValue
	// error.  If the row pointed to is removed or becomes inactive by other
	// means, the treatment is as if this attribute contains a value of
	// zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServMeterFailNext interface{}

	// This indicates the behavior of the meter by pointing to an entry containing
	// detailed parameters. Note that entries in that specific table must be
	// managed explicitly.  For example, diffServMeterSpecific may point to an
	// entry in diffServTBParamTable, which contains an instance of a single set
	// of Token Bucket parameters.  Setting this to point to a target that does
	// not exist results in an inconsistentValue error.  If the row pointed to is
	// removed or becomes inactive by other means, the meter always succeeds. The
	// type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServMeterSpecific interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServMeterStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServMeterStatus interface{}
}

DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry An entry in the meter table describes a single conformance level of a meter.

func (*DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry) GetEntityData 

func (diffServMeterEntry *DIFFSERVMIB_DiffServMeterTable_DiffServMeterEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMinRateTable 

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

	// An entry in the Minimum Rate Parameters Table describes a single set of
	// scheduling parameters for use by one or more queues or schedulers. The type
	// is slice of DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry.
	DiffServMinRateEntry []*DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry
}

DIFFSERVMIB_DiffServMinRateTable The Minimum Rate Parameters Table enumerates individual sets of scheduling parameter that can be used/reused by Queues and Schedulers.

func (*DIFFSERVMIB_DiffServMinRateTable) GetEntityData 

func (diffServMinRateTable *DIFFSERVMIB_DiffServMinRateTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry 

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

	// This attribute is a key. An index that enumerates the Scheduler Parameter
	// entries. Managers obtain new values for row creation in this table by
	// reading diffServMinRateNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServMinRateId interface{}

	// The priority of this input to the associated scheduler, relative    to the
	// scheduler's other inputs. A queue or scheduler with a larger numeric value
	// will be served before another with a smaller numeric value. The type is
	// interface{} with range: 1..4294967295.
	DiffServMinRatePriority interface{}

	// The minimum absolute rate, in kilobits/sec, that a downstream scheduler
	// element should allocate to this queue. If the value is zero, then there is
	// effectively no minimum rate guarantee. If the value is non-zero, the
	// scheduler will assure the servicing of this queue to at least this rate.
	// Note that this attribute value and that of diffServMinRateRelative are
	// coupled: changes to one will affect the value of the other. They are linked
	// by the following equation, in that setting one will change the other:
	// diffServMinRateRelative =
	// (diffServMinRateAbsolute*1000000)/ifSpeed  or, if appropriate:
	// diffServMinRateRelative = diffServMinRateAbsolute/ifHighSpeed. The type is
	// interface{} with range: 1..4294967295. Units are kilobits per second.
	DiffServMinRateAbsolute interface{}

	// The minimum rate that a downstream scheduler element should allocate to
	// this queue, relative to the maximum rate of the interface as reported by
	// ifSpeed or ifHighSpeed, in units of 1/1000 of 1. If the value is zero, then
	// there is effectively no minimum rate guarantee. If the value is non-zero,
	// the scheduler will assure the servicing of this queue to at least this
	// rate.  Note that this attribute value and that of diffServMinRateAbsolute
	// are coupled: changes to one will affect the value of the other. They are
	// linked by the following equation, in that setting one will change the
	// other:      diffServMinRateRelative =
	// (diffServMinRateAbsolute*1000000)/ifSpeed  or, if appropriate:
	// diffServMinRateRelative = diffServMinRateAbsolute/ifHighSpeed. The type is
	// interface{} with range: 1..4294967295.
	DiffServMinRateRelative interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServMinRateStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServMinRateStatus interface{}
}

DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry An entry in the Minimum Rate Parameters Table describes a single set of scheduling parameters for use by one or more queues or schedulers.

func (*DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry) GetEntityData 

func (diffServMinRateEntry *DIFFSERVMIB_DiffServMinRateTable_DiffServMinRateEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMultiFieldClfrTable 

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

	// An IP Multi-field Classifier entry describes a single filter. The type is
	// slice of
	// DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry.
	DiffServMultiFieldClfrEntry []*DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry
}

DIFFSERVMIB_DiffServMultiFieldClfrTable A table of IP Multi-field Classifier filter entries that a

system may use to identify IP traffic.

func (*DIFFSERVMIB_DiffServMultiFieldClfrTable) GetEntityData 

func (diffServMultiFieldClfrTable *DIFFSERVMIB_DiffServMultiFieldClfrTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry 

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

	// This attribute is a key. An index that enumerates the MultiField Classifier
	// filter entries.  Managers obtain new values for row creation in this table
	// by reading diffServMultiFieldClfrNextFree. The type is interface{} with
	// range: 1..4294967295.
	DiffServMultiFieldClfrId interface{}

	// The type of IP address used by this classifier entry.  While other types of
	// addresses are defined in the InetAddressType    textual convention, and DNS
	// names, a classifier can only look at packets on the wire. Therefore, this
	// object is limited to IPv4 and IPv6 addresses. The type is InetAddressType.
	DiffServMultiFieldClfrAddrType interface{}

	// The IP address to match against the packet's destination IP address. This
	// may not be a DNS name, but may be an IPv4 or IPv6 prefix.
	// diffServMultiFieldClfrDstPrefixLength indicates the number of bits that are
	// relevant. The type is string with length: 0..255.
	DiffServMultiFieldClfrDstAddr interface{}

	// The length of the CIDR Prefix carried in diffServMultiFieldClfrDstAddr. In
	// IPv4 addresses, a length of 0 indicates a match of any address; a length of
	// 32 indicates a match of a single host address, and a length between 0 and
	// 32 indicates the use of a CIDR Prefix. IPv6 is similar, except that prefix
	// lengths range from 0..128. The type is interface{} with range: 0..2040.
	// Units are bits.
	DiffServMultiFieldClfrDstPrefixLength interface{}

	// The IP address to match against the packet's source IP address. This may
	// not be a DNS name, but may be an IPv4 or IPv6 prefix.
	// diffServMultiFieldClfrSrcPrefixLength indicates the number of bits that are
	// relevant. The type is string with length: 0..255.
	DiffServMultiFieldClfrSrcAddr interface{}

	// The length of the CIDR Prefix carried in diffServMultiFieldClfrSrcAddr. In
	// IPv4 addresses, a length of 0 indicates a match of any address; a length of
	// 32 indicates a match of a single host address, and a length between 0 and
	// 32 indicates the use of a CIDR Prefix. IPv6 is similar, except that prefix
	// lengths range from 0..128. The type is interface{} with range: 0..2040.
	// Units are bits.
	DiffServMultiFieldClfrSrcPrefixLength interface{}

	// The value that the DSCP in the packet must have to match this entry. A
	// value of -1 indicates that a specific DSCP value has not been defined and
	// thus all DSCP values are considered a match. The type is interface{} with
	// range: -1..63.
	DiffServMultiFieldClfrDscp interface{}

	// The flow identifier in an IPv6 header. The type is interface{} with range:
	// 0..1048575.
	DiffServMultiFieldClfrFlowId interface{}

	// The IP protocol to match against the IPv4 protocol number or the IPv6 Next-
	// Header number in the packet. A value of 255 means match all.  Note the
	// protocol number of 255 is reserved by IANA, and Next-Header number of 0 is
	// used in IPv6. The type is interface{} with range: 0..255.
	DiffServMultiFieldClfrProtocol interface{}

	// The minimum value that the layer-4 destination port number in the packet
	// must have in order to match this classifier entry. The type is interface{}
	// with range: 0..65535.
	DiffServMultiFieldClfrDstL4PortMin interface{}

	// The maximum value that the layer-4 destination port number in the packet
	// must have in order to match this classifier entry. This value must be equal
	// to or greater than the value specified for this entry in
	// diffServMultiFieldClfrDstL4PortMin. The type is interface{} with range:
	// 0..65535.
	DiffServMultiFieldClfrDstL4PortMax interface{}

	// The minimum value that the layer-4 source port number in the packet must
	// have in order to match this classifier entry. The type is interface{} with
	// range: 0..65535.
	DiffServMultiFieldClfrSrcL4PortMin interface{}

	// The maximum value that the layer-4 source port number in the packet must
	// have in order to match this classifier entry. This value must be equal to
	// or greater than the value specified for this entry in
	// diffServMultiFieldClfrSrcL4PortMin. The type is interface{} with range:
	// 0..65535.
	DiffServMultiFieldClfrSrcL4PortMax interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServMultiFieldClfrStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServMultiFieldClfrStatus interface{}
}

DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry An IP Multi-field Classifier entry describes a single filter.

func (*DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry) GetEntityData 

func (diffServMultiFieldClfrEntry *DIFFSERVMIB_DiffServMultiFieldClfrTable_DiffServMultiFieldClfrEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServQTable 

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

	// An entry in the Queue Table describes a single queue or class of traffic.
	// The type is slice of DIFFSERVMIB_DiffServQTable_DiffServQEntry.
	DiffServQEntry []*DIFFSERVMIB_DiffServQTable_DiffServQEntry
}

DIFFSERVMIB_DiffServQTable The Queue Table enumerates the individual queues. Note that the MIB models queuing systems as composed of individual queues, one per class of traffic, even though they may in fact be structured as classes of traffic scheduled using a common calendar queue, or in other ways.

func (*DIFFSERVMIB_DiffServQTable) GetEntityData 

func (diffServQTable *DIFFSERVMIB_DiffServQTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServQTable_DiffServQEntry 

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

	// This attribute is a key. An index that enumerates the Queue entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServQNextFree. The type is interface{} with range: 1..4294967295.
	DiffServQId interface{}

	// This selects the next Differentiated Services Scheduler.  The RowPointer
	// must point to a diffServSchedulerEntry.  A value of zeroDotZero in this
	// attribute indicates an incomplete diffServQEntry instance. In such a case,
	// the entry has no operational effect, since it has no parameters to give it
	// meaning.  Setting this to point to a target that does not exist results in
	// an inconsistentValue error.  If the row pointed to is removed or becomes
	// inactive by other means, the treatment is as if this attribute contains a
	// value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServQNext interface{}

	// This RowPointer indicates the diffServMinRateEntry that the scheduler,
	// pointed to by diffServQNext, should use to service this queue.  If the row
	// pointed to is zeroDotZero, the minimum rate and priority is unspecified.
	// Setting this to point to a target that does not exist results in an
	// inconsistentValue error.  If the row pointed to is removed or becomes
	// inactive by other means, the treatment is as if this attribute contains a
	// value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServQMinRate interface{}

	// This RowPointer indicates the diffServMaxRateEntry that the scheduler,
	// pointed to by diffServQNext, should use to service this queue.  If the row
	// pointed to is zeroDotZero, the maximum rate is the line speed of the
	// interface.     Setting this to point to a target that does not exist
	// results in an inconsistentValue error.  If the row pointed to is removed or
	// becomes inactive by other means, the treatment is as if this attribute
	// contains a value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServQMaxRate interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServQStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServQStatus interface{}
}

DIFFSERVMIB_DiffServQTable_DiffServQEntry An entry in the Queue Table describes a single queue or class of traffic.

func (*DIFFSERVMIB_DiffServQTable_DiffServQEntry) GetEntityData 

func (diffServQEntry *DIFFSERVMIB_DiffServQTable_DiffServQEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServQueue 

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

	// This object contains an unused value for diffServQId, or a zero to indicate
	// that none exist. The type is interface{} with range: 0..4294967295.
	DiffServQNextFree interface{}
}

DIFFSERVMIB_DiffServQueue

func (*DIFFSERVMIB_DiffServQueue) GetEntityData 

func (diffServQueue *DIFFSERVMIB_DiffServQueue) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServRandomDropTable 

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

	// An entry describes a process that drops packets according to a random
	// algorithm. The type is slice of
	// DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry.
	DiffServRandomDropEntry []*DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry
}

DIFFSERVMIB_DiffServRandomDropTable The random drop table contains entries describing a process that drops packets randomly. Entries in this table are pointed to by diffServAlgDropSpecific.

func (*DIFFSERVMIB_DiffServRandomDropTable) GetEntityData 

func (diffServRandomDropTable *DIFFSERVMIB_DiffServRandomDropTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry 

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

	// This attribute is a key. An index that enumerates the Random Drop entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServRandomDropNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServRandomDropId interface{}

	// The average queue depth in bytes, beyond which traffic has a non-zero
	// probability of being dropped. Changes in this variable may or may not be
	// reflected in the reported value of diffServRandomDropMinThreshPkts. The
	// type is interface{} with range: 1..4294967295. Units are bytes.
	DiffServRandomDropMinThreshBytes interface{}

	// The average queue depth in packets, beyond which traffic has a non-zero
	// probability of being dropped. Changes in this variable may or may not be
	// reflected in the reported value of diffServRandomDropMinThreshBytes. The
	// type is interface{} with range: 1..4294967295. Units are packets.
	DiffServRandomDropMinThreshPkts interface{}

	// The average queue depth beyond which traffic has a probability indicated by
	// diffServRandomDropProbMax of being dropped or marked. Note that this
	// differs from the physical queue limit, which is stored in
	// diffServAlgDropQThreshold. Changes in this variable may or may not be
	// reflected in the reported value of diffServRandomDropMaxThreshPkts. The
	// type is interface{} with range: 1..4294967295. Units are bytes.
	DiffServRandomDropMaxThreshBytes interface{}

	// The average queue depth beyond which traffic has a probability indicated by
	// diffServRandomDropProbMax of being dropped or marked. Note that this
	// differs from the physical queue limit, which is stored in
	// diffServAlgDropQThreshold. Changes in this variable may or may not be
	// reflected in the reported value of diffServRandomDropMaxThreshBytes. The
	// type is interface{} with range: 1..4294967295. Units are packets.
	DiffServRandomDropMaxThreshPkts interface{}

	// The worst case random drop probability, expressed in drops per thousand
	// packets.  For example, if in the worst case every arriving packet may be
	// dropped (100%) for a period, this has the value 1000. Alternatively, if in
	// the worst case only one percent (1%) of traffic may be dropped, it has the
	// value 10. The type is interface{} with range: 0..1000.
	DiffServRandomDropProbMax interface{}

	// The weighting of past history in affecting the Exponentially Weighted
	// Moving Average function that calculates the current average queue depth.
	// The equation uses diffServRandomDropWeight/65536 as the coefficient for the
	// new sample in the equation, and (65536 - diffServRandomDropWeight)/65536 as
	// the coefficient of the old value.  Implementations may limit the values of
	// diffServRandomDropWeight to a subset of the possible range of values, such
	// as powers of two. Doing this would facilitate implementation of the
	// Exponentially Weighted Moving Average using shift instructions or
	// registers. The type is interface{} with range: 0..65536.
	DiffServRandomDropWeight interface{}

	// The number of times per second the queue is sampled for queue average
	// calculation.  A value of zero is used to mean that the queue is sampled
	// approximately each time a packet is enqueued (or dequeued). The type is
	// interface{} with range: 0..1000000.
	DiffServRandomDropSamplingRate interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServRandomDropStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServRandomDropStatus interface{}
}

DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry An entry describes a process that drops packets according to a random algorithm.

func (*DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry) GetEntityData 

func (diffServRandomDropEntry *DIFFSERVMIB_DiffServRandomDropTable_DiffServRandomDropEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServScheduler 

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

	// This object contains an unused value for diffServSchedulerId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServSchedulerNextFree interface{}

	// This object contains an unused value for diffServMinRateId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServMinRateNextFree interface{}

	// This object contains an unused value for diffServMaxRateId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServMaxRateNextFree interface{}
}

DIFFSERVMIB_DiffServScheduler

func (*DIFFSERVMIB_DiffServScheduler) GetEntityData 

func (diffServScheduler *DIFFSERVMIB_DiffServScheduler) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServSchedulerTable 

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

	// An entry in the Scheduler Table describing a single instance of a
	// scheduling algorithm. The type is slice of
	// DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry.
	DiffServSchedulerEntry []*DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry
}

DIFFSERVMIB_DiffServSchedulerTable The Scheduler Table enumerates packet schedulers. Multiple scheduling algorithms can be used on a given data path, with each algorithm described by one diffServSchedulerEntry.

func (*DIFFSERVMIB_DiffServSchedulerTable) GetEntityData 

func (diffServSchedulerTable *DIFFSERVMIB_DiffServSchedulerTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry 

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

	// This attribute is a key. An index that enumerates the Scheduler entries.
	// Managers obtain new values for row creation in this table by reading
	// diffServSchedulerNextFree. The type is interface{} with range:
	// 1..4294967295.
	DiffServSchedulerId interface{}

	// This selects the next Differentiated Services Functional Data Path Element
	// to handle traffic for this data path. This normally is null (zeroDotZero),
	// or points to a diffServSchedulerEntry or a diffServQEntry.  However, this
	// RowPointer may also point to an instance of:   diffServClfrEntry,
	// diffServMeterEntry,   diffServActionEntry,   diffServAlgDropEntry.  It
	// would point another diffServSchedulerEntry when implementing multiple
	// scheduler methods for the same data path, such as having one set of queues
	// scheduled by WRR and that group participating in a priority scheduling
	// system in which other queues compete with it in that way.  It might also
	// point to a second scheduler in a hierarchical scheduling system.  If the
	// row pointed to is zeroDotZero, no further Differentiated Services treatment
	// is performed on traffic of this data path.  Setting this to point to a
	// target that does not exist results in an inconsistentValue error.  If the
	// row pointed to is removed or becomes inactive by other means, the treatment
	// is as if this attribute contains a value of zeroDotZero. The type is string
	// with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServSchedulerNext interface{}

	// The scheduling algorithm used by this Scheduler. zeroDotZero indicates that
	// this is unknown.  Standard values for generic algorithms:
	// diffServSchedulerPriority, diffServSchedulerWRR, and diffServSchedulerWFQ
	// are specified in this MIB; additional values    may be further specified in
	// other MIBs. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServSchedulerMethod interface{}

	// This RowPointer indicates the entry in diffServMinRateTable which indicates
	// the priority or minimum output rate from this scheduler. This attribute is
	// used only when there is more than one level of scheduler.  When it has the
	// value zeroDotZero, it indicates that no minimum rate or priority is
	// imposed.  Setting this to point to a target that does not exist results in
	// an inconsistentValue error.  If the row pointed to is removed or becomes
	// inactive by other means, the treatment is as if this attribute contains a
	// value of zeroDotZero. The type is string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServSchedulerMinRate interface{}

	// This RowPointer indicates the entry in diffServMaxRateTable which indicates
	// the maximum output rate from this scheduler. When more than one maximum
	// rate applies (eg, when a multi-rate shaper is in view), it points to the
	// first of those rate entries. This attribute is used only when there is more
	// than one level of scheduler.  When it has the value zeroDotZero, it
	// indicates that no maximum rate is imposed.  Setting this to point to a
	// target that does not exist results in an inconsistentValue error.  If the
	// row pointed to is removed or becomes inactive by other means, the treatment
	// is as if this attribute contains a value of zeroDotZero. The type is string
	// with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServSchedulerMaxRate interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServSchedulerStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServSchedulerStatus interface{}
}

DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry An entry in the Scheduler Table describing a single instance of a scheduling algorithm.

func (*DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry) GetEntityData 

func (diffServSchedulerEntry *DIFFSERVMIB_DiffServSchedulerTable_DiffServSchedulerEntry) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServTBParam 

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

	// This object contains an unused value for diffServTBParamId, or a zero to
	// indicate that none exist. The type is interface{} with range:
	// 0..4294967295.
	DiffServTBParamNextFree interface{}
}

DIFFSERVMIB_DiffServTBParam

func (*DIFFSERVMIB_DiffServTBParam) GetEntityData 

func (diffServTBParam *DIFFSERVMIB_DiffServTBParam) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServTBParamTable 

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

	// An entry that describes a single set of token bucket parameters. The type
	// is slice of DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry.
	DiffServTBParamEntry []*DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry
}

DIFFSERVMIB_DiffServTBParamTable This table enumerates a single set of token bucket meter parameters that a system may use to police a stream of traffic. Such meters are modeled here as having a single rate and a single burst size. Multiple entries are used when multiple rates/burst sizes are needed.

func (*DIFFSERVMIB_DiffServTBParamTable) GetEntityData 

func (diffServTBParamTable *DIFFSERVMIB_DiffServTBParamTable) GetEntityData() *types.CommonEntityData

type DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry 

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

	// This attribute is a key. An index that enumerates the Token Bucket
	// Parameter entries. Managers obtain new values for row creation in this
	// table by reading diffServTBParamNextFree. The type is interface{} with
	// range: 1..4294967295.
	DiffServTBParamId interface{}

	// The Metering algorithm associated with the Token Bucket parameters.
	// zeroDotZero indicates this is unknown.  Standard values for generic
	// algorithms: diffServTBParamSimpleTokenBucket, diffServTBParamAvgRate,
	// diffServTBParamSrTCMBlind, diffServTBParamSrTCMAware,
	// diffServTBParamTrTCMBlind, diffServTBParamTrTCMAware, and
	// diffServTBParamTswTCM are specified in this MIB as OBJECT- IDENTITYs;
	// additional values may be further specified in other MIBs. The type is
	// string with pattern:
	// (([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))(\.(0|([1-9]\d*)))*.
	DiffServTBParamType interface{}

	// The token-bucket rate, in kilobits per second (kbps). This attribute is
	// used for: 1. CIR in RFC 2697 for srTCM 2. CIR and PIR in RFC 2698 for trTCM
	// 3. CTR and PTR in RFC 2859 for TSWTCM 4. AverageRate in RFC 3290. The type
	// is interface{} with range: 1..4294967295. Units are kilobits per second.
	DiffServTBParamRate interface{}

	// The maximum number of bytes in a single transmission burst. This attribute
	// is used for: 1. CBS and EBS in RFC 2697 for srTCM 2. CBS and PBS in RFC
	// 2698 for trTCM 3. Burst Size in RFC 3290. The type is interface{} with
	// range: 0..2147483647. Units are Bytes.
	DiffServTBParamBurstSize interface{}

	// The time interval used with the token bucket.  For: 1. Average Rate Meter,
	// the Informal Differentiated Services Model    section 5.2.1, - Delta. 2.
	// Simple Token Bucket Meter, the Informal Differentiated    Services Model
	// section 5.1, - time interval t. 3. RFC 2859 TSWTCM, - AVG_INTERVAL. 4. RFC
	// 2697 srTCM, RFC 2698 trTCM, - token bucket update time    interval. The
	// type is interface{} with range: 1..4294967295. Units are microseconds.
	DiffServTBParamInterval interface{}

	// The storage type for this conceptual row.  Conceptual rows having the value
	// 'permanent' need not allow write-access to any columnar objects in the row.
	// The type is StorageType.
	DiffServTBParamStorage interface{}

	// The status of this conceptual row. All writable objects in this row may be
	// modified at any time. Setting this variable to 'destroy' when the MIB
	// contains one or more RowPointers pointing to it results in destruction
	// being delayed until the row is no longer used. The type is RowStatus.
	DiffServTBParamStatus interface{}
}

DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry An entry that describes a single set of token bucket parameters.

func (*DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry) GetEntityData 

func (diffServTBParamEntry *DIFFSERVMIB_DiffServTBParamTable_DiffServTBParamEntry) GetEntityData() *types.CommonEntityData

type DiffServSchedulerPriority 

type DiffServSchedulerPriority struct {
}

func (DiffServSchedulerPriority) String 

func (id DiffServSchedulerPriority) String() string

type DiffServSchedulerWFQ 

type DiffServSchedulerWFQ struct {
}

func (DiffServSchedulerWFQ) String 

func (id DiffServSchedulerWFQ) String() string

type DiffServSchedulerWRR 

type DiffServSchedulerWRR struct {
}

func (DiffServSchedulerWRR) String 

func (id DiffServSchedulerWRR) String() string

type DiffServTBParamAvgRate 

type DiffServTBParamAvgRate struct {
}

func (DiffServTBParamAvgRate) String 

func (id DiffServTBParamAvgRate) String() string

type DiffServTBParamSimpleTokenBucket 

type DiffServTBParamSimpleTokenBucket struct {
}

func (DiffServTBParamSimpleTokenBucket) String 

func (id DiffServTBParamSimpleTokenBucket) String() string

type DiffServTBParamSrTCMAware 

type DiffServTBParamSrTCMAware struct {
}

func (DiffServTBParamSrTCMAware) String 

func (id DiffServTBParamSrTCMAware) String() string

type DiffServTBParamSrTCMBlind 

type DiffServTBParamSrTCMBlind struct {
}

func (DiffServTBParamSrTCMBlind) String 

func (id DiffServTBParamSrTCMBlind) String() string

type DiffServTBParamTrTCMAware 

type DiffServTBParamTrTCMAware struct {
}

func (DiffServTBParamTrTCMAware) String 

func (id DiffServTBParamTrTCMAware) String() string

type DiffServTBParamTrTCMBlind 

type DiffServTBParamTrTCMBlind struct {
}

func (DiffServTBParamTrTCMBlind) String 

func (id DiffServTBParamTrTCMBlind) String() string

type DiffServTBParamTswTCM 

type DiffServTBParamTswTCM struct {
}

func (DiffServTBParamTswTCM) String 

func (id DiffServTBParamTswTCM) String() string

type IfDirection 

type IfDirection string

IfDirection represents transmission on the interface. 

const (
	IfDirection_inbound IfDirection = "inbound"

	IfDirection_outbound IfDirection = "outbound"
)

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.