Standardmethoden

Bei der Generierung der Klassen werden zwei Varianten für die Initialisierung der MIB-M-Beans verwendet. Eine Initialisierung baut lediglich die SNMP-MIB-Struktur innerhalb des JDMK-Agenten auf, ohne die dabei generierten M-Beans innerhalb des Core Management Frameworks zu registrieren. Diese Art der Initialisierung wird dann verwendet, falls der JDMK-Agent als Standalone SNMP-Agent agieren soll. Es ist aber dann nicht möglich, über andere Adapter auf diese generierten M-Beans zuzugreifen. Die andere Variante der Initialisierung registriert die generierten M-Beans zusätzlich und ermöglicht so die Nutzung der von JDMK bereitgestellten Dienste und Protokolle (es ist zu beachten, daß bei der ersten Variante ohne Registrierung die Dienste des JDMK nicht genutzt werden können).

// Konstruktor einer Implementierung des generierten M-Beans
// NetworkParms. Es stellt eine Gruppe innerhalb der MIB dar.

public NetworkParmsImpl(SnmpMib myMib, Framework cmf) {
   super(myMib);
   init(myMib, cmf);

    // Get these Objects to insert and remove Tableentries
   NetworkParmsMIB = myMib;
   NetworkParmsCMF = cmf;
}

Bei der Initialisierung werden die einzelnen Properties der Klasse (bzw. des M-Beans) mit Werten aus den TIS-Applikationen, welche mit dem entsprechenden M-Bean gemanagt werden sollen, belegt. Die Properties werden innerhalb der Superklasse (also der generierten) festgelegt. Dies sind einfache MIB-Variablen wie OCTET STRING und INTEGER:

...
// Festlegung einer OCTET STRING - Variablen
// SYNTAX : DisplayString
/**
 * Variable for storing the value of "ComputerName".
 * The variable is identified by: "1.3.6.1.4.1.2206.5.1.1.1.1".
 */
protected String ComputerName= null;
...
// Festlegung einer OCTET STRING - Variablen
// SYNTAX : DisplayString
/**
 * Variable for storing the value of "IpAddress".
 * The variable is identified by: "1.3.6.1.4.1.2206.5.1.1.1.3".
 */
protected Byte[] IpAddress = null;
...
// Festlegung der Tabellen
/**
 * Variable for storing the value of "DnsServerTable".
 * The variable is identified by: "1.3.6.1.4.1.2206.5.1.1.1.7".
 */
protected TableDnsServerTable DnsServerTable;

Wie in diesem Beispiel-Code dargestellt, wird eine Tabelle nur als grobe Rahmenstruktur zur Verfügung gestellt, welche Methoden zum Zugriff auf seine Tabelleneinträge zur Verfügung stellt, da die eigentliche Information in den Einträgen vorhanden ist. So werden Klassen, welche den Tabellenbezeichner, gefolgt von dem Suffix ``Entry'' tragen, erzeugt. Diese Klassen müssen mit den implementierten Klassen erweitert werden, um zum Beispiel eine Möglichkeit zum Entfernen von Tabelleneinträgen zu schaffen. Es muß im Sinne der kaskadierenden Erstellung der M-Beans (siehe Kap. 6.3.1) eine Speicherungsstruktur geschaffen werden. Zudem ist für das Einfügen und Entfernen von Tabelleneinträgen eine Referenz auf die MIB (Eintrag in MIB-Struktur des JDMK-Agenten) und das Core Management Framework (Registrierung des M-Beans) zur Verfügung zu stellen. Aus diesem Grund werden weitere Membervariablen zu den Implementierungsklassen hinzugenommen. Nachfolgend ist ein Beispiel für solche Variablen zu sehen:

// Zusaetzliche Membervariablen bei Implementierungen
...
// 
// Private variables.
//
private SnmpMib NetworkParmsMIB;
private Framework NetworkParmsCMF;
private Vector NetworkParmsImplListeners = new Vector();

private static DnsServerEntryImpl DnsServerEntry[] 
        = new DnsServerEntryImpl[10];
private static DomainSuffixEntryImpl DomainSuffixEntry[] 
        = new DomainSuffixEntryImpl[10];
private static IpGatewayEntryImpl IpGatewayEntry[] 
        = new IpGatewayEntryImpl[10];
...

Da in der generierten Klasse die Elemente der MIB-Gruppe mit Dummy-Werten vorbelegt werden, müssen in der Initialisierungsphase die realen Werte ermittelt werden. Dabei wird zwischen tabellen- und nicht-tabelleneigenen Einträgen sowie Enumerationen unterschieden:

• Tabelleneinträge
  Hier wird eine Methode init<Klassenbezeichner Tabelle> mit Übergabe eines MIB- und CMF-Objektes aufgerufen. Diese Methode beinhaltet die notwendigen OID's für die Spalten der Tabelle als Integer- und String-Array. Diese Zweiteilung, welche nur bei der Initialisierung von Tabellen benutzt wird, hat hier den Vorteil daß bei den Native-Methoden wie getNextStringNative bzw. getNextIntNative die nächste OID wieder zurückgegeben wird. An dieser Stelle würde die Konvertierung der Daten unnötige Probleme aufwerfen. Die String-Variante wird üblicherweise verwendet, insbesondere da JDMK entsprechende Packages zur Verfügung stellt (siehe Kap. 6.3), die diese Verwendung nahelegen. Innerhalb dieser Initialisierungsmethode werden nun die Einträge der Tabelle spaltenweise abgearbeitet. Die String-Variante der OID-Darstellung dient hier bei einem ersten Durchlauf zur Ermittlung der Anzahl der Einträge. Nachfolgend ist ein Beispiel einer solchen Initialisierungs-Methode zu sehen:

  private void initDnsServerTable(SnmpMib myMib, Framework cmf) {
     //Loading the DnsServerTable
     //to initialize, it's better to use the oid as an integer-array
     int[][] oid = {{1,3,6,1,4,1,2206,5,1,1,1,7,1,1}
                    , {1,3,6,1,4,1,2206,5,1,1,1,7,1,2}};
     String[] StartOid = {"1.3.6.1.4.1.2206.5.1.1.1.7.1.1"
                          , "1.3.6.1.4.1.2206.5.1.1.1.7.1.2"};
  
     int entries = 0;
     int NrOfRows;
     int tempInt = 0;
     DnsServerEntry[entries] 
          = new DnsServerEntryImpl(myMib, cmf, DnsServerTable);
     boolean NoMoreRows = false;
  
     // Get the DnsServerIndex
     try {
         tempInt = nativeBase.getNextIntNative(oid,0);
        DnsServerEntry[entries].setDnsServerIndex(new Integer(tempInt));
        NoMoreRows = (StartOid[0].equals(tools.ConvertTools.Int2String(oid)[0]));
     } catch (Exception e) {
        e.printStackTrace();
     }
  
     while (!NoMoreRows) {
        entries++;
        DnsServerEntry[entries] = new DnsServerEntryImpl(myMib);
        try {
           tempInt = nativeBase.getNextIntNative(oid,0);
           DnsServerEntry[entries].setDnsServerIndex(new Integer(tempInt));
           NoMoreRows = (StartOid[0].equals(tools.ConvertTools.Int2String(oid)[0]));
        } catch (IllegalArgumentException iae) {
        // no more rows !??
           NoMoreRows = true;
        } catch (Exception e) {
           e.printStackTrace();
        }
     }
  
     NrOfRows = entries;
  
     // Get the DnsServerAddr
     // inputOID now at first Element of second column
     entries = 0;
     while (entries != NrOfRows) {
        String tempDnsServerAddr = null;
        try {
           tempDnsServerAddr = new String(nativeBase.getNextStringNative(oid,1));
           DnsServerEntry[entries]
          .setDnsServerAddr(tools.ConvertTools.String2Byte(tempDnsServerAddr));
        } catch (Exception e) {
           e.printStackTrace();
        }
        entries++;
     }
  
     entries = 0;
     while (entries != NrOfRows) {
        try {
           //Register in DnsServerTable
           DnsServerTable.addEntry(DnsServerEntry[entries]);
        } catch (Exception e) {
           e.printStackTrace();
        }
        try {
           //Register in Core management Framework
           DnsServerEntry[entries].addInCmf(cmf);
        } catch (Exception e) {
              e.printStackTrace();
        }
        entries++;
     }
  }

• Nicht-Tabelleneinträge
  Bei diesen Einträgen werden durch einfache getStringNative- und getIntNative- Methoden die entsprechenden Werte ermittelt. Die OID wird hier als String-Variante verwendet. Ein Konvertierung in ein Integer-Array ist dadurch notwendig geworden, da innerhalb des Java Native Interface die Datenstruktur RFC1157Varbind (vgl. 6.5) die OID als Integer-Array voraussetzt. Um aber das Interface möglichst schmal zu halten, wurde die Konvertierung auf der Java-Seite durchgeführt. Das folgende Codestück stellt eine solche Methode dar:

  /**
  * Getter for the "ComputerName" variable.
  */
  public String getComputerName() throws SnmpStatusException {
     String oid = "1.3.6.1.4.1.2206.5.1.1.1.1.0";
     ComputerName = nativeBase.getStringNative(tools.ConvertTools.String2Int(oid));
     return ComputerName;
  }

• Enumerationen
  Da Enumerationen als eigene Klassen generiert werden (siehe Kap. 6.3.1), müssen auch diese Einträge gesondert behandelt werden. Es werden zwar ebenso get- und set- Methoden verwendet, jedoch ist der Inhalt davon geprägt, den Wert, welcher von der Applikation erhalten wird, auf das Enumerations-Objekt abzubilden. Dies geschieht mittels einer switch-Anweisung. Eine get-Methode kann somit folgendermaßen aussehen:

  /**
   * Getter for the "EnableDnsForWindows" variable.
   */
  public EnumEnableDnsForWindows getEnableDnsForWindows() 
          throws SnmpStatusException {
     String oid = "1.3.6.1.4.1.2206.5.1.1.1.9";
     switch (nativeBase.getIntNative(tools.ConvertTools.String2Int(oid))) {
     case 1:
        EnableDnsForWindows = new EnumEnableDnsForWindows(1);
        break;
     case 2:
        EnableDnsForWindows = new EnumEnableDnsForWindows(2);
        break;
     default:
        EnableDnsForWindows = new EnumEnableDnsForWindows();
     }
     return EnableDnsForWindows;
  }

Ebenso wie die get-Methoden, werden auch set-Methoden zur Verfügung gestellt. Es wird ebenso die OID als String verwendet, die Änderung erfolgt durch Anwendung der Native-Methode setNative. Fehlerfälle (Exceptions) können durch das Einfügen der Werte in die JDMK-MIB-Struktur und bei Änderungen der Werte in den Applikationen entstehen. Diese Fehlerfälle werden bis jetzt mit Ausgabe des Trace-Stacks abgefangen.