snmp4jlogmib.java

你个snmp的源码

/*_############################################################################
  _##
  _##  SNMP4J-Agent - Snmp4jLogMib.java
  _##
  _##  Copyright 2005-2006  Frank Fock (SNMP4J.org)
  _##
  _##  Licensed under the Apache License, Version 2.0 (the "License");
  _##  you may not use this file except in compliance with the License.
  _##  You may obtain a copy of the License at
  _##
  _##      http://www.apache.org/licenses/LICENSE-2.0
  _##
  _##  Unless required by applicable law or agreed to in writing, software
  _##  distributed under the License is distributed on an "AS IS" BASIS,
  _##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  _##  See the License for the specific language governing permissions and
  _##  limitations under the License.
  _##
  _##########################################################################*/


package org.snmp4j.agent.mo.snmp4j;

//--AgentGen BEGIN=_BEGIN
//--AgentGen END

import org.snmp4j.smi.*;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.agent.*;
import org.snmp4j.agent.mo.*;
import org.snmp4j.agent.mo.snmp.*;
import org.snmp4j.agent.request.*;
import org.snmp4j.log.LogFactory;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogLevel;
import org.snmp4j.PDU;

//--AgentGen BEGIN=_IMPORT
import java.util.Iterator;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import org.snmp4j.agent.mo.snmp4j.Snmp4jLogMib.Snmp4jLogLoggerRow;
//--AgentGen END

public class Snmp4jLogMib
//--AgentGen BEGIN=_EXTENDS
//--AgentGen END
implements MOGroup
//--AgentGen BEGIN=_IMPLEMENTS
    ,MOServerLookupListener
    ,MOTableRowListener
    ,RowStatusListener
//--AgentGen END
{

  private static final LogAdapter LOGGER =
      LogFactory.getLogger(Snmp4jLogMib.class);

//--AgentGen BEGIN=_STATIC
  private static final MOTableRowFilter NOT_ACTIVE_ROW_FILTER =
      new MOTableRowFilter() {
    public boolean passesFilter(MOTableRow row) {
      if (row instanceof Snmp4jLogLoggerRow) {
        Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow)row;
        if (r.getSnmp4jLogLoggerRowStatus().getValue() == RowStatus.active) {
          return false;
        }
      }
      return true;
    }

  };
//--AgentGen END

  // Factory
  private static MOFactory moFactory = DefaultMOFactory.getInstance();

  // Constants
  private static final OID oidSnmp4jLogSysDescr =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,1,1,0 });
  private static final OID oidSnmp4jLogFactory =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,1,2,0 });
  private static final OID oidSnmp4jLogRootLevel =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,1,0 });

  // Scalars
  private MOScalar snmp4jLogSysDescr;
  private MOScalar snmp4jLogFactory;
  private MOScalar snmp4jLogRootLevel;

  // Tables
  private static final OID oidSnmp4jLogLoggerEntry =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,2,1 });

  // Column sub-identifer defintions for snmp4jLogLoggerEntry:
  private static final int colSnmp4jLogLoggerIndex = 2;
  private static final int colSnmp4jLogLoggerLevel = 3;
  private static final int colSnmp4jLogLoggerEffectiveLevel = 4;
  private static final int colSnmp4jLogLoggerStorageType = 5;
  private static final int colSnmp4jLogLoggerRowStatus = 6;

  // Column index defintions for snmp4jLogLoggerEntry:
  private static final int idxSnmp4jLogLoggerIndex = 0;
  private static final int idxSnmp4jLogLoggerLevel = 1;
  private static final int idxSnmp4jLogLoggerEffectiveLevel = 2;
  private static final int idxSnmp4jLogLoggerStorageType = 3;
  private static final int idxSnmp4jLogLoggerRowStatus = 4;
  private static MOTableSubIndex[] snmp4jLogLoggerEntryIndexes =
    new MOTableSubIndex[] {
        moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 127)
  };

  private static MOTableIndex snmp4jLogLoggerEntryIndex =
      moFactory.createIndex(snmp4jLogLoggerEntryIndexes,
                            true,
                            new MOTableIndexValidator() {
    public boolean isValidIndex(OID index) {
      boolean isValidIndex = true;
     //--AgentGen BEGIN=snmp4jLogLoggerEntry::isValidIndex
     //--AgentGen END
      return isValidIndex;
    }
  });


  private MOTable             snmp4jLogLoggerEntry;
  private MOMutableTableModel snmp4jLogLoggerEntryModel;
  private static final OID oidSnmp4jLogLoggerToHandlerEntry =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,3,1 });

  // Column sub-identifer defintions for snmp4jLogLoggerToHandlerEntry:
  private static final int colSnmp4jLogLoggerToHandlerThreshold = 1;
  private static final int colSnmp4jLogLoggerToHandlerStorageType = 2;
  private static final int colSnmp4jLogLoggerToHandlerRowStatus = 3;

  // Column index defintions for snmp4jLogLoggerToHandlerEntry:
  private static final int idxSnmp4jLogLoggerToHandlerThreshold = 0;
  private static final int idxSnmp4jLogLoggerToHandlerStorageType = 1;
  private static final int idxSnmp4jLogLoggerToHandlerRowStatus = 2;
  private static MOTableSubIndex[] snmp4jLogLoggerToHandlerEntryIndexes =
    new MOTableSubIndex[] {
        moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1),
        moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
  };

  private static MOTableIndex snmp4jLogLoggerToHandlerEntryIndex =
      moFactory.createIndex(snmp4jLogLoggerToHandlerEntryIndexes,
                            false,
                            new MOTableIndexValidator() {
    public boolean isValidIndex(OID index) {
      boolean isValidIndex = true;
     //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::isValidIndex
     //--AgentGen END
      return isValidIndex;
    }
  });


  private MOTable             snmp4jLogLoggerToHandlerEntry;
  private MOMutableTableModel snmp4jLogLoggerToHandlerEntryModel;
  private static final OID oidSnmp4jLogHandlerEntry =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,2,1 });

  // Column sub-identifer defintions for snmp4jLogHandlerEntry:
  private static final int colSnmp4jLogHandlerType = 2;
  private static final int colSnmp4jLogHandlerStorageType = 3;
  private static final int colSnmp4jLogHandlerRowStatus = 4;

  // Column index defintions for snmp4jLogHandlerEntry:
  private static final int idxSnmp4jLogHandlerType = 0;
  private static final int idxSnmp4jLogHandlerStorageType = 1;
  private static final int idxSnmp4jLogHandlerRowStatus = 2;
  private static MOTableSubIndex[] snmp4jLogHandlerEntryIndexes =
    new MOTableSubIndex[] {
        moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
  };

  private static MOTableIndex snmp4jLogHandlerEntryIndex =
      moFactory.createIndex(snmp4jLogHandlerEntryIndexes,
                            false,
                            new MOTableIndexValidator() {
    public boolean isValidIndex(OID index) {
      boolean isValidIndex = true;
     //--AgentGen BEGIN=snmp4jLogHandlerEntry::isValidIndex
     //--AgentGen END
      return isValidIndex;
    }
  });


  private MOTable             snmp4jLogHandlerEntry;
  private MOMutableTableModel snmp4jLogHandlerEntryModel;
  private static final OID oidSnmp4jLogFileHandlerEntry =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,3,1,1 });

  // Column sub-identifer defintions for snmp4jLogFileHandlerEntry:
  private static final int colSnmp4jLogFileHandlerPath = 1;
  private static final int colSnmp4jLogFileHandlerAppend = 2;
  private static final int colSnmp4jLogFileHandlerBufferedIO = 3;
  private static final int colSnmp4jLogFileHandlerBufferSize = 4;

  // Column index defintions for snmp4jLogFileHandlerEntry:
  private static final int idxSnmp4jLogFileHandlerPath = 0;
  private static final int idxSnmp4jLogFileHandlerAppend = 1;
  private static final int idxSnmp4jLogFileHandlerBufferedIO = 2;
  private static final int idxSnmp4jLogFileHandlerBufferSize = 3;
  private static MOTableSubIndex[] snmp4jLogFileHandlerEntryIndexes =
    new MOTableSubIndex[] {
        moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
  };

  private static MOTableIndex snmp4jLogFileHandlerEntryIndex =
      moFactory.createIndex(snmp4jLogFileHandlerEntryIndexes,
                            false,
                            new MOTableIndexValidator() {
    public boolean isValidIndex(OID index) {
      boolean isValidIndex = true;
     //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::isValidIndex
     //--AgentGen END
      return isValidIndex;
    }
  });


  private MOTable             snmp4jLogFileHandlerEntry;
  private MOMutableTableModel snmp4jLogFileHandlerEntryModel;
  private static final OID oidSnmp4jLogConsoleHandlerEntry =
    new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,3,2,1 });

  // Column sub-identifer defintions for snmp4jLogConsoleHandlerEntry:
  private static final int colSnmp4jLogConsoleHandlerTarget = 1;

  // Column index defintions for snmp4jLogConsoleHandlerEntry:
  private static final int idxSnmp4jLogConsoleHandlerTarget = 0;
  private static MOTableSubIndex[] snmp4jLogConsoleHandlerEntryIndexes =
    new MOTableSubIndex[] {
        moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 127)
  };

  private static MOTableIndex snmp4jLogConsoleHandlerEntryIndex =
      moFactory.createIndex(snmp4jLogConsoleHandlerEntryIndexes,
                            false,
                            new MOTableIndexValidator() {
    public boolean isValidIndex(OID index) {
      boolean isValidIndex = true;
     //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::isValidIndex
     //--AgentGen END
      return isValidIndex;
    }
  });


  private MOTable             snmp4jLogConsoleHandlerEntry;
  private MOMutableTableModel snmp4jLogConsoleHandlerEntryModel;


  //--AgentGen BEGIN=_MEMBERS
  private Map loggers = new HashMap();
  private Map loggerNames2Index = new WeakHashMap();
  private int nextLoggerIndex = 1;
  //--AgentGen END

  public Snmp4jLogMib() {
    snmp4jLogSysDescr =
      moFactory.createScalar(oidSnmp4jLogSysDescr, MOAccessImpl.ACCESS_READ_ONLY, new OctetString());
    snmp4jLogFactory =
      moFactory.createScalar(oidSnmp4jLogFactory, MOAccessImpl.ACCESS_READ_ONLY, new OctetString());
    snmp4jLogRootLevel =
      new Snmp4jLogRootLevel(oidSnmp4jLogRootLevel, MOAccessImpl.ACCESS_READ_WRITE);
    snmp4jLogRootLevel.addMOValueValidationListener(new Snmp4jLogLevelValidator());
    createSnmp4jLogLoggerEntry();
    createSnmp4jLogLoggerToHandlerEntry();
    createSnmp4jLogHandlerEntry();
    createSnmp4jLogFileHandlerEntry();
    createSnmp4jLogConsoleHandlerEntry();
//--AgentGen BEGIN=_DEFAULTCONSTRUCTOR
//--AgentGen END
  }


  public MOTable getSnmp4jLogLoggerEntry() {
    return snmp4jLogLoggerEntry;
  }


  private void createSnmp4jLogLoggerEntry() {
    MOColumn[] snmp4jLogLoggerEntryColumns = new MOColumn[5];
    snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerIndex] =
      new MOColumn(colSnmp4jLogLoggerIndex,
                   SMIConstants.SYNTAX_INTEGER32,
                   MOAccessImpl.ACCESS_READ_ONLY);
    snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerLevel] =
      new MOMutableColumn(colSnmp4jLogLoggerLevel,
                          SMIConstants.SYNTAX_INTEGER,
                          MOAccessImpl.ACCESS_READ_CREATE,
                          new Integer32(1),
                          true);
    ((MOMutableColumn)snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerLevel]).
      addMOValueValidationListener(new Snmp4jLogLevelValidator());
    snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerEffectiveLevel] =
      new MOColumn(colSnmp4jLogLoggerEffectiveLevel,
                   SMIConstants.SYNTAX_INTEGER,
                   MOAccessImpl.ACCESS_READ_ONLY);
    snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerStorageType] =
      new StorageType(colSnmp4jLogLoggerStorageType,
                      MOAccessImpl.ACCESS_READ_CREATE,
                      new Integer32(2),
                      true);
    snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerRowStatus] =
      new RowStatus(colSnmp4jLogLoggerRowStatus);

    snmp4jLogLoggerEntryModel = new DefaultMOMutableTableModel();
    snmp4jLogLoggerEntryModel.setRowFactory(new Snmp4jLogLoggerEntryRowFactory());
    snmp4jLogLoggerEntry =
      moFactory.createTable(oidSnmp4jLogLoggerEntry,
                         snmp4jLogLoggerEntryIndex,
                            snmp4jLogLoggerEntryColumns,
                            snmp4jLogLoggerEntryModel);
    ((RowStatus)snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerRowStatus]).
        addRowStatusListener(this);
    snmp4jLogLoggerEntry.addMOTableRowListener(this);
    updateLoggerTable();
  }

  public MOTable getSnmp4jLogLoggerToHandlerEntry() {
    return snmp4jLogLoggerToHandlerEntry;
  }


  private void createSnmp4jLogLoggerToHandlerEntry() {
    MOColumn[] snmp4jLogLoggerToHandlerEntryColumns = new MOColumn[3];
    snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerThreshold] =
      new MOMutableColumn(colSnmp4jLogLoggerToHandlerThreshold,
                          SMIConstants.SYNTAX_INTEGER,
                          MOAccessImpl.ACCESS_READ_CREATE,
                          new Integer32(2),
                          true);
    ((MOMutableColumn)snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerThreshold]).
      addMOValueValidationListener(new Snmp4jLogLevelValidator());
    snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerStorageType] =
      new StorageType(colSnmp4jLogLoggerToHandlerStorageType,
                      MOAccessImpl.ACCESS_READ_CREATE,
                      new Integer32(2),
                      true);
    snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerRowStatus] =
      new RowStatus(colSnmp4jLogLoggerToHandlerRowStatus);