Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.sun.management.oss.pm.measurement
Interface JVTPerformanceMonitorSession

All Superinterfaces:
  JVTSession

All Known Implementing Classes:
  JmxJVTPerformanceMonitorSession

public interface JVTPerformanceMonitorSession
extends JVTSession

The JVTPerformanceMonitorSession interface is the central interface of this package to manage measurement jobs.

This interface defines administrative functions that a performance monitoring agent shall support. The administration functions are:

- Creating a measurement job
- Deleting a measurement job
- Suspending/resuming a measurement job
- Get measurement job
- Get supported report formats
- Get supported observable objects
- Retrieval of measurement reports

Creating a measurement job: On creation of a measurement job, all information has to be supplied in order to collect the required data from the selected resources as specified by the measurement job.

Deleting a measurement job: A measurement job is automatically deleted by the system when it reaches the job end time and all scheduled measurement reports have been generated. A created measurement job can also be deleted by manual intervention at any time. When deleted, the measurement process associated with the job is stopped, and all allocated resources are freed.

Suspending/resuming a measurement job: On normal operation, the measurement job collects measurement data according to the actual values of the measurement job parameters. However, the system operator may decide for some reason to discard temporarily the collection of measurement data (e.g. in case of system overload or congestion, measurement results not used,...). The system operator therefore is able to suspend a defined measurement job at any time. This implies that the measurement job definition remains in the system, but that no measurement gathering activities are performed for this measurement job. When the measurement job is resumed, measurement data collection is started again at the next granularity period within the measurement schedule. These operations are optional.

Get a measurement job: The users of the interface shall be able to get a list of all measurements that are currently defined, together with all available actual information as stored. This information consists of the data that is supplied on creation/modification and the actual state information of the measurement job.

Get report formats: The bean implementation shall provide the functions to determine the current measurement report format.

Get supported observable objects: A discover mechanisms is provided to find the supported observable object classes and observable object instances. Observable object instances can be found by using observable object class or by specifying a JMX pattern where the observable object instances are hierarchicaly located below. Mechanism to find the performance attributes associated with an Observable Object class is also provided.

Retrieval of measurement reports: Each measurement job will collect measurement data at a particular frequency, known as the granularity period of the measurement. At the end of the granularity period a scheduled measurement report shall be generated for each measurement job that is actively collecting performance measurement data. These measurement reports of the measurement data collection can be forwarded to the client in two standard ways:

- the scheduled measurement reports can be sent to the client as soon as they are available,
- the measurement reports can be stored and transferred to or retrieved when required.

The measurement reports shall be forwarded to the client in one or both of the above standard ways. It shall be possible for the client to specify the details for its measurement retrieval. It is also necessary to support the possibility for multiple destinations for transfer of data, in the case of several clients required the produced measurement reports.

The first case will forward the measurement report in a event to the client. This event contains the measurement report data and is issued when the report mode is set to event.

The second case requires implementation of local storage of the measurement reports and that an event is sent to the clients when the data is available. This event contains the identity/location of the measurement report and shall be issued when the local stored measurement report is created. The implementation shall provide function to find available stored measurement reports.

The operation that returns the supported entity value types, `getManagedEntityTypes()`, shall return `com.sun.management.oss.pm.measurement.PerformanceMonitorByObjectsValue.VALUE_TYPE` entity value type.

The operation that creates a managed entity value instances for a specific managed entity value type, `makeManagedEntityValue(String)`, shall create an instance of `com.sun.management.oss.pm.measurement.PerformanceMonitorByObjectsValue` if the input parameter is equal to `com.sun.management.oss.pm.measurement.PerformanceMonitorByObjectsValue.VALUE_TYPE`. If the managed entity value type `com.sun.management.oss.pm.measurement.PerformanceMonitorByClassValue` is supported and the it shall create an instance of that type if the input parameter is equal to `com.sun.management.oss.pm.measurement.PerformanceMonitorByClassValue.VALUE_TYPE`.

The operation that returns the supported event types, `getEventTypes()`, shall return `com.sun.management.oss.pm.measurement.PerformanceDataAvailableEventDescriptor.OSS_EVENT_TYPE_VALUE`.

The operation that gets the event descriptor of an event type, `getEventDescriptor( String )`, shall return an event descriptor of `com.sun.management.oss.pm.measurement.PerformanceDataAvailableEventDescriptor` if the input parameter is equal `com.sun.management.oss.pm.measurement.PerformanceDataAvailableEventDescriptor.OSS_EVENT_TYPE_VALUE`. If the event type `com.sun.management.oss.pm.measurement.PerformanceDataEvent` is supported, then an instance of `com.sun.management.oss.pm.measurement.PerformanceDataEventDescriptor` shall be created if the input parameter is equal `com.sun.management.oss.pm.measurement.PerformanceDataEventDescriptor.OSS_EVENT_TYPE_VALUE`.

The operation that returns the supported query value types, `getQueryTypes()` shall return `com.sun.management.oss.pm.measurement.QueryPerformanceMonitorValue.QUERY_TYPE` and `com.sun.management.oss.pm.measurement.QueryByDNValue.QUERY_TYPE`.

The operation that creates a query value instances for a specific query type, `makeQueryValue(String)`, shall create an instance of `com.sun.management.oss.pm.measurement.QueryPerformanceMonitorValue` if the input parameter is equal to `com.sun.management.oss.pm.measurementQueryPerformanceMonitorValue.QUERY_TYPE`. If the query type `com.sun.management.oss.pm.measurement.QueryByDNValue` is supported, then an instance of `com.sun.management.oss.pm.measurement.QueryByDNValue` shall be created if the input parameter is equal `com.sun.management.oss.pm.measurement.QueryByDNValue.QUERY_TYPE`.

The operation `queryManagedEntities( QueryValue, String[])` shall have the same behaviour as the `queryPerformanceMonitors( QueryValue, String[])` operation.

Version:
  0.9.1, 2002-02-21
Author:
  Stefan Aberg

Field Summary
`static java.lang.String` | `OSS_QOS_VERSION_R1` Version constant for the first release of OSS QoS API.

Method Summary
`PerformanceMonitorKey` | `createPerformanceMonitorByValue(PerformanceMonitorValue pmValue)` Creates a new measurement job.
`ReportFormat` | `getCurrentReportFormat()` Returns the current measurement result format that the performance monitor agent use.
`CurrentResultReport` | `getCurrentResultReport(PerformanceMonitorKey pmKey, ReportFormat format)` Generate a result report of the current measurement result values.
`PerformanceAttributeDescriptor[]` | `getObservableAttributes(java.lang.String observableObjectClassName)` Returns all measurement attributes that can be monitored in the observable object class, in the performance monitoring agent.
`ObservableObjectClassIterator` | `getObservableObjectClasses()` Returns all supported observed object classes in the performance monitoring agent.
`ObservableObjectIterator` | `getObservableObjects(java.lang.String observableObjectClassName, javax.management.ObjectName base)` Returns the supported observable object instances (JMX ObjectName objects) of the specific object class that are matching the specified JMX pattern in the performance monitoring agent.
`PerformanceMonitorValue` | `getPerformanceMonitorByKey(PerformanceMonitorKey pmKey, java.lang.String[] attributes)` Gets the attribute values of a specific measurement job.
`PerformanceMonitorValueIterator` | `getPerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKey, java.lang.String[] attributes)` Gets a list of attribute values of the specific measurement jobs.
`ReportInfoIterator` | `getPerformanceReportInfo(PerformanceMonitorKey pmKey, java.util.Calendar date)` Returns a list of available measurement result in the performance monitor agent.
`ReportFormat[]` | `getReportFormats()` Returns the supported measurement result formats of the performance monitor agent.
`int[]` | `getReportModes()` Returns the supported report modes of the performance monitor agent.
`int[]` | `getSupportedGranularities(PerformanceMonitorValue pmValue)` Returns the supported granularity periods for the provided definition of a measurement job.
`javax.management.ObjectName[]` | `getSupportedObservableObjects(javax.management.ObjectName[] dnList)` Checks a list of distinguished names if they are supported observable objects.
`java.lang.String[]` | `getVersion()` Retrieve information of the supported API versions.
`PerformanceMonitorValue` | `makePerformanceMonitorValue(java.lang.String value)` Creates a new value object for a measurement job.
`PerformanceMonitorValueIterator` | `queryPerformanceMonitors(QueryValue query, java.lang.String[] attrNames)` Queries for multiple measurement jobs using a query value instance.
`void` | `removePerformanceMonitorByKey(PerformanceMonitorKey pmKey)` Remove measurement job.
`void` | `resumePerformanceMonitorByKey(PerformanceMonitorKey pmKey)` Re-enables the measurement job to collect measurement data.
`void` | `suspendPerformanceMonitorByKey(PerformanceMonitorKey pmKey)` Inhibits the measurement job from collection of measurement data.
`PerformanceMonitorKeyResult[]` | `tryCreatePerformanceMonitorsByValues(PerformanceMonitorValue[] pmValues)` Try to create measurement jobs.
`PerformanceMonitorKeyResult[]` | `tryRemovePerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)` Try to remove measurement jobs.
`PerformanceMonitorKeyResult[]` | `tryResumePerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)` Try to re-enables the measurement jobs to collect measurement data.
`PerformanceMonitorKeyResult[]` | `trySuspendPerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)` Try to inhibit measurement jobs from collection of measurement data.

Methods inherited from interface com.sun.management.oss.JVTSession
`getEventDescriptor, getEventTypes, getManagedEntityTypes, getQueryTypes, getSupportedOptionalOperations, makeManagedEntityValue, makeQueryValue, queryManagedEntities`

Field Detail

### OSS_QOS_VERSION_R1

    public static final java.lang.String OSS_QOS_VERSION_R1

  Version constant for the first release of OSS QoS API.

  See Also:
    Constant Field Values

Method Detail

### getVersion

    public java.lang.String[] getVersion()

  Retrieve information of the supported API versions.

  The operation shall indicate compatibility with the first release of OSS QoS API.

  If more then one version is supported then the latest supported OSS QoS API version shall be in the first entry of the returned array.

  At least one OSS QoS API version and a vendor version shall be returned by this operation.

  This operation could also be used to identify the version of implementation and the version of the supported standards (3GPP).

  Returns:
    String[] Array of supported version strings.

### makePerformanceMonitorValue

    public PerformanceMonitorValue makePerformanceMonitorValue(java.lang.String value)
                                                        throws java.lang.IllegalArgumentException

  Creates a new value object for a measurement job.

  Parameters:
    `value` - The name of one of the supported value types that are returned by `getManagedEntityTypes()`.
  Returns:
    PerformanceMonitorValue The created value object. The value object is empty.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if the input paramters are not valid.

### getReportFormats

    public ReportFormat[] getReportFormats()

  Returns the supported measurement result formats of the performance monitor agent.

  At least one report format must be returned by this operation.

  Returns:
    ReportFormat[] List of supported measurement result formats.

### getCurrentReportFormat

    public ReportFormat getCurrentReportFormat()

  Returns the current measurement result format that the performance monitor agent use.

  This function can be used to determine the measurement result format that the performance monitor agent currently is using for result reports with many measurement jobs.

  Returns:
    ReportFormat The current measurement result file format.

### getReportModes

    public int[] getReportModes()

  Returns the supported report modes of the performance monitor agent.

  The implementaion must support one of the file report modes, `ReportMode.FILE_SINGLE` or `ReportMode.FILE_MULTIPLE`. The other report modes are optional. The report mode `ReportMode.NO_REPORT_MODE` can not be returned by this operation.

  Returns:
    int[] List of supported report modes.
  See Also:
    `ReportMode`

### getObservableObjectClasses

    public ObservableObjectClassIterator getObservableObjectClasses()

  Returns all supported observed object classes in the performance monitoring agent.

  Returns:
    ObservableObjectClassIterator Iterator that contains all supported observable object classes.

### getObservableObjects

    public ObservableObjectIterator getObservableObjects(java.lang.String observableObjectClassName,
                                                         javax.management.ObjectName base)
                                                  throws java.lang.IllegalArgumentException

  Returns the supported observable object instances (JMX ObjectName objects) of the specific object class that are matching the specified JMX pattern in the performance monitoring agent.

  `base` is a JMX pattern to use for finding the observable objects.

  Parameters:
    `observableObjectClassName` - The class name of the observable object instances to be found.
    `base` - The JMX pattern to use for the search.
  Returns:
    ObservableObjectIterator Iterator that contains all supported observable objects (JMX ObjectName objects).
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if the input parameters are not valid/null.

### getSupportedObservableObjects

    public javax.management.ObjectName[] getSupportedObservableObjects(javax.management.ObjectName[] dnList)

  Checks a list of distinguished names if they are supported observable objects.

  This operation is used to determine which observable objects are supported in a measurement job.

  If none of the observable objects are supported an empty array is returned. If an object is supported, it is present in the returned list.

  Parameters:
    `dnList` - The list of object names you want to know if they are monitorable (i.e: jobs can be created for these objects).
  Returns:
    List of object names for observable objects that can be observed. This list contains a subset of object names included in the `dnList` parameter.

### getObservableAttributes

    public PerformanceAttributeDescriptor[] getObservableAttributes(java.lang.String observableObjectClassName)
                                                             throws java.lang.IllegalArgumentException

  Returns all measurement attributes that can be monitored in the observable object class, in the performance monitoring agent.

  For each observable objects that are supported, minimum one attribute must be returned.

  Parameters:
    `observableObjectClassName` - The name of the observable object class.
  Returns:
    PerformanceAttributeDescriptor[] List of all supported measurement attributes in the observable object class.
  Throws:
    `java.lang.IllegalArgumentException` - is raised if the input parameters is not valid.
  See Also:
    `PerformanceAttributeDescriptor`

### getSupportedGranularities

    public int[] getSupportedGranularities(PerformanceMonitorValue pmValue)
                                    throws java.lang.IllegalArgumentException

  Returns the supported granularity periods for the provided definition of a measurement job.

  This operation returns a list of granularity periods that can be used when a measurement job shall be created, with the specified definition of the measurement job.

  If no granularity period is supported for the specified instances and attributes, an empty array shall be returned.

  The returned granularity periods shall be seconds.

  Parameters:
    `pmValue` - The attributes of the measurement job except the granularity period.
  Returns:
    int[] List of supported granularity periods in seconds.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised when the input parameters are not valid.

### getPerformanceReportInfo

    public ReportInfoIterator getPerformanceReportInfo(PerformanceMonitorKey pmKey,
                                                       java.util.Calendar date)
                                                throws java.lang.IllegalArgumentException,
                                                       ObjectNotFoundException

  Returns a list of available measurement result in the performance monitor agent.

  During the recording intervals specified for measurement jobs, scheduled measurement reports are generated at the end of each granularity period if the measurement jobs are not suspended.

  Measurement jobs that have the distribution set to file will add its measurement report to a measurement result file. A list of reference to these generated measurement result files is returned, to allow retrieval of the measurement result files.

  The storage capacity and duration as well as the method how the data may be deleted are implementation dependent.

  If a performance monitor key is specified all result files containing that measurement job is returned. This is only applicable if the performance monitor agent stores measurement reports per measurement job.

  If the date is specified all result files created after that date is returned.

  If some of the input parameters should not be specified a `null` value should be specified. If both parameters are specified, a logical `AND` will be used to find the result files. If both parameters are `null`, all result files will be returned.

  Parameters:
    `pmKey` - The primary key of a measurement job, that shall be included in the reports.
    `date` - Specifies the minimum creation date for the reports.
  Returns:
    ReportInfoIterator Iterator that contains all measurement result files.
  Throws:
    `ObjectNotFoundException` - Is raised if the measurement job was not found.
    `java.lang.IllegalArgumentException` - is raised if the input paramters are not valid.

### getPerformanceMonitorByKey

    public PerformanceMonitorValue getPerformanceMonitorByKey(PerformanceMonitorKey pmKey,
                                                              java.lang.String[] attributes)
                                                       throws ObjectNotFoundException,
                                                              java.lang.IllegalArgumentException

  Gets the attribute values of a specific measurement job.

  The input parameters specify which attributes to get on the measurement job. If the attribute id list is an empty array then all attribute values of the measurement jobs are returned.

  Parameters:
    `pmKey` - Primary key of the measurement job.
    `attributes` - A list of the attributes to be returned.
  Returns:
    PerformanceMonitoringValue The attribute values for the requested measurement job.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised when the input parameters are not valid.
    `ObjectNotFoundException` - Is raised if the measurement job is not found.

### getPerformanceMonitorsByKeys

    public PerformanceMonitorValueIterator getPerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKey,
                                                                        java.lang.String[] attributes)
                                                                 throws FinderException,
                                                                        java.lang.IllegalArgumentException

  Gets a list of attribute values of the specific measurement jobs.

  The input parameters specify which attributes to get on the measurement jobs. If the attribute id list is an empty array then all attribute values of the measurement jobs are returned. if the array of measurement job keys is empty then all measurement jobs are returned.

  Parameters:
    `pmKey` - Primary keys of the measurement jobs.
    `attributes` - A list of the attributes to be returned.
  Returns:
    PerformanceMonitorValueIterator Iterator that contains attribute values for each requested measurement job.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised when the input parameters are not valid.
    `FinderException` - Is raised if one or several measurement jobs where not found.

### queryPerformanceMonitors

    public PerformanceMonitorValueIterator queryPerformanceMonitors(QueryValue query,
                                                                    java.lang.String[] attrNames)
                                                             throws java.lang.IllegalArgumentException

  Queries for multiple measurement jobs using a query value instance.

  The operation returns a list of attribute values of the specific measurement jobs that match the provided query.

  The first input parameter specifies a query value instance that each measurement jobs must match, if the measurement jobs attribute values shall be returned. If the firts input parameter is an empty query value, then all measurement jobs are returned. The attribute values to be returned are specified by the second input parameter. If the attribute list is an empty array then all attribute values of the measurement jobs are returned.

  If the first input parameter can be a `com.sun.management.oss.pm.measurement.QueryPerformanceMonitorValue` or a `com.sun.management.oss.pm.measurement.QueryByDNValue` or a vendor defined query, that the operation `getQueryTypes()` returns.

  Parameters:
    `query` - Search attributes with values to be match in each measurement job.
    `attrNames` - A list of the attributes to be returned.
  Returns:
    PerformanceMonitorValueIterator A iterator of measurement job values.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if the query type is not supported or the attribute names is not supported.

### createPerformanceMonitorByValue

    public PerformanceMonitorKey createPerformanceMonitorByValue(PerformanceMonitorValue pmValue)
                                                          throws java.lang.IllegalArgumentException,
                                                                 CreateException,
                                                                 DuplicateKeyException

  Creates a new measurement job.

  On creation of a measurement job, all needed information has to be supplied in order to collect the required data from the selected resources as specified by the measurement job.

  If the value object is of the type `PerformanceMonitorByObjectsValue` all observable object instances must support the attributes that are requested (same name and type) if specific attributes are requested. If the attribute list is omitted (no specific attributes request), all attributes of the specified objects will be monitored (in that case, it is not mandatory for the observed objects to have the same attributes).

  If the value object is of the type `PerformanceMonitorByClassesValue` all observable object classes must support the attributes that should be monitored. If the attribute list is omitted all attributes of every classes will be monitored.

  If the name of the measurement job is set it needs to be unique within the performance monitor agent. If the name is omitted, the name will be automatically affected a unique value (same string as primary key may be a good unique name).

  The set of observable object instances and measurement attributes has a set of supported granularity periods. These granularity periods can be retrieved from the operation `getSupportedGranularities()`. The specified granularity period must be one of the supported granularity periods.

  The specified report mode must be one of the supported reports modes, that can be retrieved from the method `getReportModes()`. If the report mode is set to `ReportMode.FILE_SINGLE` and the reporting period has not been set, the reporting period will be the same as the granularity period of the measurement job. If the granularity period is set to zero (0), then no reports will be generated and the measurement data can only be gathered on request from the client (`getCurrentResultReport()`).

  The specified report format must be one of the supported reports formats, that can be retrieved from the method `getReportFormats()`. If the report format is not specified the report format will be set to the report format that the `getCurrentReportFormat()` returns. If the report mode is set to `ReportMode.FILE_MULTIPLE` or `EVENT_MULTIPLE` the client can not set the report format. The result reports will be generated in the format that the `getCurrentReportFormat()` returns.

  The implementation shall support a measurement job start time (schedule) of up to at least 30 days from the measurement job creation date. It shall also validate that the start and end time is not a time in the past and that the end time is greater then start time. The recording intervals may repeat on a daily and/or weekly basis and specify the time periods during which the measurement data is collected. The daily interval is defined by start times and end times, which lie between 00.00 and 24.00 hours, aligned on granularity period boundaries. Thus the length of a daily interval will be a multiple of the granularity period. The daily intervals can not be overlapped.

  On creation of a measurement job the state is set to active and depending of the schedule it will be on duty or off duty. If the state is set to suspended on creation and the agent supports the suspension of jobs, the state job will be suspended and the schedule will be ignored until the job is resumed.

  The value object that is passed to this method should have been created by calling the operations that creates value object, such as `makePerformanceMonitorValue(String)`. If the value object is not created by these methods then it is implementation dependant if the create operation will work.

  If the value object includes a performance monitor key then the `IllegalArgumentException` is raised.

  Parameters:
    `pmValue` - The input parameters to create a measurement job.
  Returns:
    PerformanceMonitorKey The primary key of the created measurement job.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `CreateException` - Is raised if the measurement job could not be created.
    `DuplicateKeyException` - Is raised if an measurement job cannot be created because a measurement job with the same key already exists.

### tryCreatePerformanceMonitorsByValues

    public PerformanceMonitorKeyResult[] tryCreatePerformanceMonitorsByValues(PerformanceMonitorValue[] pmValues)
                                                                       throws java.lang.IllegalArgumentException,
                                                                              UnsupportedOperationException,
                                                                              DuplicateKeyException

  Try to create measurement jobs.

  This operation try to create a number of measurement jobs. The operation has a best effort behavior and return a list results that indicate if the operation was successful or not on each measurement job.

  The measurement jobs that should be created shall be done in accordance with the behavior of the `createPerformanceMonitor(...)`, which creates a single measurement job.

  Parameters:
    `pmValues` - The input parameters to create measurement jobs.
  Returns:
    PerformanceMonitorResultKey[] List of result information of the measurement jobs.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.
    `DuplicateKeyException` - Is raised if an measurement job cannot be created because a measurement job with the same key already exists.

### removePerformanceMonitorByKey

    public void removePerformanceMonitorByKey(PerformanceMonitorKey pmKey)
                                       throws java.lang.IllegalArgumentException,
                                              ObjectNotFoundException,
                                              RemoveException

  Remove measurement job.

  The measurement process associated with the measurement job is stopped, all allocated resources are freed. The stored measurement result reports, that are related to the measurement job shall not be removed. The measurement result reports should be removed only when the storage duration of the stored measurement result reports expires.

  A measurement job is automatically removed by the system when it reaches the monitoring end-time, and all scheduled or explicitly requested measurement reports have been generated.

  Parameters:
    `pmKey` - Primary key of the measurement job to be removed.
  Throws:
    `RemoveException` - Is raised if job could not be removed.
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `ObjectNotFoundException` - Is raised if the measurement job was not found.

### tryRemovePerformanceMonitorsByKeys

    public PerformanceMonitorKeyResult[] tryRemovePerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)
                                                                     throws java.lang.IllegalArgumentException,
                                                                            UnsupportedOperationException

  Try to remove measurement jobs.

  This operation try to remove a number of measurement jobs. The operation has a best effort behavior and return a list results that indicate if the operation was successful or not on each measurement job.

  The measurement jobs that should be removed shall be done in accordance with the behavior of the `removePerformanceMonitor(...)`, which removes a single measurement job.

  Parameters:
    `pmKeys` - List of primary keys of the measurement jobs to delete.
  Returns:
    PerformanceMonitorResultKey[] List of measurement jobs that could not be removed else null is returned.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.

### suspendPerformanceMonitorByKey

    public void suspendPerformanceMonitorByKey(PerformanceMonitorKey pmKey)
                                        throws java.lang.IllegalArgumentException,
                                               UnsupportedOperationException,
                                               ObjectNotFoundException

  Inhibits the measurement job from collection of measurement data.

  This function can be used to temporarily discard the collection of measurement data (e.g. in case of system overload or congestion, measurement results not used,...). The measurement job can be suspended at any time. This implies that the measurement job definitions remains in the system, but that no measurement gathering activities are performed for this monitoring. When the measurement job is resumed, measurement data collection is started again at the next granularity period within the measurement schedule.

  The resume function will re-enable measurement data collection according to the measurement job schedule.

  Requesting the current measurement result values of a measurement job is NOT possible when the measurement job is suspended.

  No scheduled measurement reports are generated when the measurement job is suspended.

  If the measurement job is already suspended the measurement will remain suspended.

  Parameters:
    `pmKey` - Primary keys of the measurement job to be suspended.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.
    `ObjectNotFoundException` - Is raised if the measurement job was not found.

### trySuspendPerformanceMonitorsByKeys

    public PerformanceMonitorKeyResult[] trySuspendPerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)
                                                                      throws java.lang.IllegalArgumentException,
                                                                             UnsupportedOperationException

  Try to inhibit measurement jobs from collection of measurement data.

  This operation try to inhibit a number of measurement jobs. The operation has a best effort behavior and return a list results that indicate if the operation was successful or not on each measurement job.

  The measurement jobs that should be inhibit shall be done in accordance with the behavior of the `suspendPerformanceMonitor(...)`, which removes a single measurement job.

  Parameters:
    `pmKeys` - List of primary keys of the measurement jobs to be suspended.
  Returns:
    PerformanceMonitorResultKey[] List of measurement jobs that could not be suspended else null is returned.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.

### resumePerformanceMonitorByKey

    public void resumePerformanceMonitorByKey(PerformanceMonitorKey pmKey)
                                       throws java.lang.IllegalArgumentException,
                                              UnsupportedOperationException,
                                              ObjectNotFoundException

  Re-enables the measurement job to collect measurement data.

  The measurement job in the request starts to collect measurement data at the next granularity period within the measurement schedule.

  This implies that the measurement job definition, which are remained in the system, are used when the measurement job is resumed.

  If the measurement job is already active the measurement will remain active.

  Parameters:
    `pmKey` - Primary key of the measurement job to be resumed.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.
    `ObjectNotFoundException` - Is raised if the measurement job was not found.

### tryResumePerformanceMonitorsByKeys

    public PerformanceMonitorKeyResult[] tryResumePerformanceMonitorsByKeys(PerformanceMonitorKey[] pmKeys)
                                                                     throws java.lang.IllegalArgumentException,
                                                                            UnsupportedOperationException

  Try to re-enables the measurement jobs to collect measurement data.

  This operation try to re-enable a number of measurement jobs. The operation has a best effort behavior and return a list results that indicate if the operation was successful or not on each measurement job.

  The measurement jobs that should be re-enable shall be done in accordance with the behavior of the `resumePerformanceMonitor(...)`, which resume a single measurement job.

  Each measurement job in the request starts to collect measurement data at the next granularity period within the measurement schedule.

  This implies that the measurement job definition, which are remained in the system, are used when the measurement job is resumed.

  If the measurement jobs are already active the measurement will remain active.

  Parameters:
    `pmKeys` - List of primary keys of the measurement jobs to be resumed.
  Returns:
    PerformanceMonitorKeyResult[] List of measurement jobs that could not be resumed else null is returned.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.

### getCurrentResultReport

    public CurrentResultReport getCurrentResultReport(PerformanceMonitorKey pmKey,
                                                      ReportFormat format)
                                               throws java.lang.IllegalArgumentException,
                                                      UnsupportedOperationException,
                                                      ObjectNotFoundException,
                                                      java.lang.IllegalStateException

  Generate a result report of the current measurement result values.

  An external system may for some reason be interested in the current values of the measurement job, independently of the scheduled data collection and subsequent reporting, e.g. for tracing the increment of some of the counters. To this aim, this method generates a result report of the current values of the measurement job for the same network resources as defined in the measurement job. The current measurement result is returned in the specified report format. If no report format is specified then the report format will be the same as in the measurement job definition.

  This operation does not affect the measurement job, and may only be issued when the measurement job is active and not suspended. If the measurement job is suspended, the method will raise the IllegalStateException exception.

  Parameters:
    `pmKey` - Primary key of the measurement job.
    `format` - Defines the report format of the current measurement values.
  Returns:
    CurrentResultReport The measurement result of the current values of the measurement job for the same resources as defined in the measurement job.
  Throws:
    `java.lang.IllegalArgumentException` - Is raised if parameters are wrong.
    `UnsupportedOperationException` - Is raised if this operation is not supported.
    `ObjectNotFoundException` - Is raised if the measurement job was not found.
    `java.lang.IllegalStateException` - Is raised if the measurement job is suspended.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD