Gauge/Counter-Monitoring

  Ein Dienst des JDMK, welcher auf das Event-Modell aufsetzt, ist das Monitoring. Es können wie in Kapitel 3.7.11 beschrieben, Gauge und Counter-Monitore verwendet werden. Innerhalb des TIS-Management ist dies ein wesentlicher Punkt, da mit diesem Dienst die zur Verfügung stehende Bandbreite für eine Übertragung und auch die Gesamtzahl der Kommunikationsverbindungen überwacht werden kann.
Die Handhabung erfolgt wie bei den benutzerdefinierten Events. Es ist ebenso eine Event-Klasse, welche die Klasse MonitorEvent (von JDMK angeboten) erweitert, zu implementieren. Damit kann zusätzliche Information in ein Event-Objekt integriert werden. Allerdings ist die Handhabung der auftretenden Events umfangreicher wie bei den benutzerdefinierten Events. Dies betrifft insbesondere die jeweilige Client-Applikation und die Monitor-Listener-Klasse. Die wesentlichen Punkte sind nachfolgend aufgeführt:

• Client-Applikation
  Hier muß unterschieden werden, ob es sich um einen Counter- oder Gauge-Monitor handelt.
  • Counter-Monitor
    Bei einem Counter-Monitor sind die obere Schranke bei Beginn der Zählung, ein Offset, welcher gegebenenfalls bei Überschreitung der Schranke aufaddiert wird und ein Modulus mitanzugeben, wobei Letzterer das Verhalten bei Überschreitung eines Wertebereichs bestimmt. Ein Beispiel für die Verwendung eines Counter-Monitors innerhalb des TIS kann folgendermaßen aussehen:

    package ...
    imports ...
    ...
    public class Client implements Runnable {
    ...
      // Create a counter monitor m-bean.
      // 
      String GkStatsCurrentNoOfCallsMonitorClass 
        = "com.sun.jaw.impl.agent.services.monitor.CounterMonitor";
      ObjectName GkStatsCurrentNoOfCallsMonitorName 
        = new ObjectName(domain 
                         + ":com.sun.jaw.impl.agent.services.monitor.CounterMonitorMO.id
                            =GkStatsCurrentNoOfCalls");
      CounterMonitorMO GkStatsCurrentNoOfCallsMonitor 
        = (CounterMonitorMO) adaptor.cb_newMO(GkStatsCurrentNoOfCallsMonitorClass,
                                              GkStatsCurrentNoOfCallsMonitorName, 
                                              null);
    ...
      // Set the values of the counter monitor object.
      // The counter monitor will check every second the value of the
      // "GkStatsCurrentNoOfCalls" property for the GkStatistics m-bean.
      // A threshold reached monitor event will be emited if the 
      // "GkStatsCurrentNoOfCalls" property value reached or exceeded the 
      // comparison level.
      // If the comparison level is reached or exceeded the comparison level
      // will be incremented by the offset value.
      //
      GkStatsCurrentNoOfCallsMonitor
          .setObservedObject(GkStatisticsImplName);
      GkStatsCurrentNoOfCallsMonitor
          .setObservedProperty("GkStatsCurrentNoOfCalls");
      GkStatsCurrentNoOfCallsMonitor
          .setNotifyOnOff(Boolean.TRUE);
      GkStatsCurrentNoOfCallsMonitor
          .setComparisonLevel(GkStatsCurrentNoOfCallsHigh);
      GkStatsCurrentNoOfCallsMonitor
          .setOffsetValue(offSet);
      GkStatsCurrentNoOfCallsMonitor
          .setGranularityPeriod(new Integer(1000));
      GkStatsCurrentNoOfCallsMonitor
          .setModulusValue(new Integer(32));
      GkStatsCurrentNoOfCallsMonitor
          .performStart();
    ...
      // Register a monitor listener with the counter monitor,
      // enabling the client to receive monitor events emitted by the
      // counter monitor. 
      //
      GkStatsCurrentNoOfCallsMonitor.addMonitorListenerMO(listen);
    ...

    Wie aus dem Beispiel ersichtlich, kann ebenso die Überwachung ausgesetzt (setNotifyOn/Off), das Listener-Objekt aktiviert/deaktiviert (performStart/Stop) und die Zeitspanne der Überwachungszeitpunkte (setGranularityPeriod) angegeben werden.
  • Gauge-Monitor
    Ist ein Gauge-Monitor anzulegen, dann müssen weitere Einstellungen vor der Verwendung durchgeführt werden. Es wird kein Modulus verwendet, es ist aber notwendig, die Besonderheit, welche durch die Überwachung von Bandbreite zu Tage tritt, zu berücksichtigen. Diese besteht in der Festlegung der oberen und unteren Schranke, in welcher sich der Wert bewegen darf. Die Funktionsweise ist in Kapitel 3.7.11 beschrieben. Nachfolgend ist ein Beispiel für die Verwendung dieses Monitor innerhalb des TIS zu sehen.

    packages ...
    imports ...
    ...
    public class Client implements Runnable {
    ...
      // Create a gauge monitor m-bean.
      //
      String GkStatsCurrentBandwidthMonitorClass 
        = "com.sun.jaw.impl.agent.services.monitor.GaugeMonitor";
      ObjectName GkStatsCurrentBandwidthMonitorName 
        = new ObjectName(domain 
                         + ":com.sun.jaw.impl.agent.services.monitor.GaugeMonitorMO.id
                         =GkStatsCurrentBandwidth");
      GaugeMonitorMO GkStatsCurrentBandwidthMonitor 
        = (GaugeMonitorMO) adaptor.cb_newMO(GkStatsCurrentBandwidthMonitorClass, 
                                            GkStatsCurrentBandwidthMonitorName, 
                                            null);
    ...
      // Initialize the threshold values for the gauge monitor.
      Integer GkStatsCurrentBandwidthHigh 
          = new Integer(GkStatisticsImpl.getGkStatsCurrentBandwidth()
                                        .intValue() + 15);
      Integer GkStatsCurrentBandwidthLow 
          = new Integer(GkStatisticsImpl.getGkStatsCurrentBandwidth()
                                        .intValue() - 15);
      // Set the values of the gauge monitor object.
      // The gauge monitor will check every second the value of the
      // "GkStatsCurrentBandwidth" property for the AskMe m-bean.
      // A threshold high monitor event will be emited if the 
      // "GkStatsCurrentBandwidth"
      // property value reached or exceeded the high threshold value.
      // A threshold low monitor event will be emited if the 
      // "GkStatsCurrentBandwidth"
      // property value reached or fell below the low threshold value.
      GkStatsCurrentBandwidthMonitor
          .setObservedObject(GkStatisticsImplName);
      GkStatsCurrentBandwidthMonitor
          .setObservedProperty("GkStatsCurrentBandwidth");
      GkStatsCurrentBandwidthMonitor
          .setNotifyLowOnOff(Boolean.TRUE);
      GkStatsCurrentBandwidthMonitor
          .setNotifyHighOnOff(Boolean.TRUE);
      GkStatsCurrentBandwidthMonitor
          .setThresholdLowValue(GkStatsCurrentBandwidthLow);
      GkStatsCurrentBandwidthMonitor
          .setThresholdHighValue(GkStatsCurrentBandwidthHigh);
      GkStatsCurrentBandwidthMonitor
          .setGranularityPeriod(new Integer(1000));
      GkStatsCurrentBandwidthMonitor.performStart();
      // Register a monitor listener with the gauge monitor,
      // enabling the client to receive monitor events emitted by the
      // gauge monitor. 
      GkStatsCurrentBandwidthMonitor.addMonitorListenerMO(listen);
    ...

• Monitor-Listener-Klasse
  Ebenso wie in der Client-Applikation ist der Verarbeitung von Events in der Listener-Klasse besondere Beachtung zu schenken. In dieser Klasse werden die Events nach ihrer Art unterschieden. Es werden folgende Event-Typen unterschieden:
  • GRANULARITY_PERIOD_EVT
    Dieser Event tritt auf, wenn die Zeitspanne, in welcher die Überwachung einer bestimmten M-Bean-Property, stattfindet, einen negativen Wert oder null ist.
  • OBSERVED_OBJECT_EVT
    Falls eine M-Bean (bzw. deren Property) angesprochen wird, die nicht innerhalb des CMF des jeweiligen Agenten registriert ist, tritt dieser Event auf.
  • OBSERVED_PROPERTY_EVT
    Tritt auf, falls das Property, welches überwacht werden soll, von dem angesprochenen M-Bean nicht unterstützt wird.
  • OBSERVED_PROPERTY_TYPE_EVT
    Tritt auf, falls der falsche Property-Typ verwendet wird.
  • COMPARISON_LEVEL_EVT
    Tritt auf, falls ein negativer Schrankenwert angegeben wird. Dieser Typ von Event wird nur von Counter-Monitoren gesendet.
  • OFFSET_VALUE_EVT
    Tritt auf, falls ein negativer Offsetwert angegeben wird. Dieser Typ von Event wird nur von Counter-Monitoren gesendet.
  • MODULUS_VALUE_EVT
    Tritt auf, falls ein negativer Modulus angegeben wird. Dieser Typ von Event wird nur von Counter-Monitoren gesendet.
  • THRESHOLD_VALUE_REACHED_EVT
    Tritt auf, falls die Property, welche überwacht wird, die vorher festgelegte Schranke überschreitet. Danach kann entschieden werden, ob ein Offset addiert werden soll, oder eine andere Aktion ausgeführt wird. Dieser Typ von Event wird nur von Counter-Monitoren gesendet.
  • THRESHOLD_TYPE_EVT
    Tritt auf, falls der Typ von der unteren Schranke mit dem von der oberen Schranke nicht übereinstimmt. Es ist notwendig für ein sinnvolles Überwachen, gleiche Typen zu verwenden. Dieser Typ von Event wird nur von Gauge-Monitoren gesendet.
  • THRESHIGH_LOWER_THAN_THRESLOW_EVT
    Tritt auf, wenn die obere Schranke kleiner als die untere Schranke ist. Falls negative Werte verarbeitet werden sollen, so ist entweder mit Absolutwerten zu arbeiten, oder die Schranken sinnvoll umzubenennen. Dieser Typ von Event wird nur von Gauge-Monitoren gesendet.
  • THRESHOLD_HIGH_VALUE_EXCEEDED_EVT
    Tritt auf, wenn die überwachte Property die obere Schranke überschreitet. Dieser Typ von Event wird nur von Gauge-Monitoren gesendet.
  • THRESHOLD_LOW_VALUE_EXCEEDED_EVT
    Tritt auf, wenn die überwachte Property die untere Schranke unterschreitet. Dieser Typ von Event wird nur von Gauge-Monitoren gesendet.
  Die Unterscheidung zwischen diesen Arten ist innerhalb der Monitor-Listener-Klasse zu treffen. Ein Beispiel bei der Verwendung innerhalb des TIS-Prototypen hat folgende Gestalt:

  packages ...
  imports ...
  ...
  public class ClientListener implements MonitorListenerMO {
  ...
    public void handleMonitor(MonitorEventMO event) {
      // Get a handle on the monitor responsable for the event
      // emmited.
         MonitorMO Monitor = (MonitorMO) event.getSource();
      // Process the different types of events fired by the monitors.
      //
      try {
        switch (event.getMonitorEventType().intValue()) {
          case MonitorEvent.COMPARISON_LEVEL_EVT:
          case MonitorEvent.GRANULARITY_PERIOD_EVT:
          case MonitorEvent.MODULUS_VALUE_EVT:
          case MonitorEvent.OBSERVED_OBJECT_EVT:
          case MonitorEvent.OBSERVED_PROPERTY_EVT:
          case MonitorEvent.OBSERVED_PROPERTY_TYPE_EVT:
          case MonitorEvent.OFFSET_VALUE_EVT:
          case MonitorEvent.THRESHIGH_LOWER_THAN_THRESLOW_EVT:
          case MonitorEvent.THRESHOLD_TYPE_EVT:
          case MonitorEvent.THRESHOLD_HIGH_VALUE_EXCEEDED_EVT:
          System.out.println("Clientlistener: Monitor event -- " 
                                + event.getMonitorEventObservedProperty() 
                                + " Has Exceeded The Threshold High -- Value = " 
                                + event.getMonitorEventDerivedGauge()); 
          System.out.println("Clientlistener: GkStatsCurrentBandwidth HIGH"); 
        break;
        case MonitorEvent.THRESHOLD_LOW_VALUE_EXCEEDED_EVT:
          System.out.println("Clientlistener: Monitor event - " 
                              + event.getMonitorEventObservedProperty() 
                              + " Has Exceeded The Threshold Low >> Value = " 
                              + event.getMonitorEventDerivedGauge());
          System.out.println("Clientlistener: GkStatsCurrentBandwidth LOW"); 
        break;
        case MonitorEvent.THRESHOLD_VALUE_REACHED_EVT:
          System.out.println("Clientlistener: Monitor event -- " 
                              + event.getMonitorEventObservedProperty() 
                              + " Has Reached The Threshold -- Value " 
                              + event.getMonitorEventDerivedGauge());
          System.out.println("Clientlistener: 
                              GkStatsCurrentNoOfCalls increased by 5"); 
        break;
      default:
        System.out.println("Clientlistener: Unknown event Type (?)");
      }
    } catch (Exception e) {
      System.out.println("Got An Exception !");
      System.out.println(e);
    }
  ...
  }