snmp4jlogmib.java

你个snmp的源码

    public Integer32 getSnmp4jLogLoggerStorageType() {
      return (Integer32) getValue(idxSnmp4jLogLoggerStorageType);
    }

    public void setSnmp4jLogLoggerStorageType(Integer32 newValue) {
      setValue(idxSnmp4jLogLoggerStorageType, newValue);
    }

    public Integer32 getSnmp4jLogLoggerRowStatus() {
      return (Integer32) getValue(idxSnmp4jLogLoggerRowStatus);
    }

    public void setSnmp4jLogLoggerRowStatus(Integer32 newValue) {
      setValue(idxSnmp4jLogLoggerRowStatus, newValue);
    }


     //--AgentGen BEGIN=snmp4jLogLoggerEntry::RowFactory
     //--AgentGen END
  }

  class Snmp4jLogLoggerToHandlerEntryRowFactory
        extends DefaultMOMutableRow2PCFactory
  {
    public MOTableRow createRow(OID index, Variable[] values)
        throws UnsupportedOperationException
    {
      Snmp4jLogLoggerToHandlerEntryRow row = new Snmp4jLogLoggerToHandlerEntryRow(index, values);
     //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::createRow
     //--AgentGen END
      return row;
    }

    public void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::freeRow
     //--AgentGen END
    }
  }

  class Snmp4jLogLoggerToHandlerEntryRow extends DefaultMOMutableRow2PC {
    public Snmp4jLogLoggerToHandlerEntryRow(OID index, Variable[] values) {
      super(index, values);
    }

    public Integer32 getSnmp4jLogLoggerToHandlerThreshold() {
      return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerThreshold);
    }

    public void setSnmp4jLogLoggerToHandlerThreshold(Integer32 newValue) {
      setValue(idxSnmp4jLogLoggerToHandlerThreshold, newValue);
    }

    public Integer32 getSnmp4jLogLoggerToHandlerStorageType() {
      return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerStorageType);
    }

    public void setSnmp4jLogLoggerToHandlerStorageType(Integer32 newValue) {
      setValue(idxSnmp4jLogLoggerToHandlerStorageType, newValue);
    }

    public Integer32 getSnmp4jLogLoggerToHandlerRowStatus() {
      return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerRowStatus);
    }

    public void setSnmp4jLogLoggerToHandlerRowStatus(Integer32 newValue) {
      setValue(idxSnmp4jLogLoggerToHandlerRowStatus, newValue);
    }


     //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::RowFactory
     //--AgentGen END
  }

  class Snmp4jLogHandlerEntryRowFactory
        extends DefaultMOMutableRow2PCFactory
  {
    public MOTableRow createRow(OID index, Variable[] values)
        throws UnsupportedOperationException
    {
      Snmp4jLogHandlerEntryRow row = new Snmp4jLogHandlerEntryRow(index, values);
     //--AgentGen BEGIN=snmp4jLogHandlerEntry::createRow
     //--AgentGen END
      return row;
    }

    public void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=snmp4jLogHandlerEntry::freeRow
     //--AgentGen END
    }
  }

  class Snmp4jLogHandlerEntryRow extends DefaultMOMutableRow2PC {
    public Snmp4jLogHandlerEntryRow(OID index, Variable[] values) {
      super(index, values);
    }

    public OID getSnmp4jLogHandlerType() {
      return (OID) getValue(idxSnmp4jLogHandlerType);
    }

    public void setSnmp4jLogHandlerType(OID newValue) {
      setValue(idxSnmp4jLogHandlerType, newValue);
    }

    public Integer32 getSnmp4jLogHandlerStorageType() {
      return (Integer32) getValue(idxSnmp4jLogHandlerStorageType);
    }

    public void setSnmp4jLogHandlerStorageType(Integer32 newValue) {
      setValue(idxSnmp4jLogHandlerStorageType, newValue);
    }

    public Integer32 getSnmp4jLogHandlerRowStatus() {
      return (Integer32) getValue(idxSnmp4jLogHandlerRowStatus);
    }

    public void setSnmp4jLogHandlerRowStatus(Integer32 newValue) {
      setValue(idxSnmp4jLogHandlerRowStatus, newValue);
    }


     //--AgentGen BEGIN=snmp4jLogHandlerEntry::RowFactory
     //--AgentGen END
  }

  class Snmp4jLogFileHandlerEntryRowFactory
        extends DefaultMOMutableRow2PCFactory
  {
    public MOTableRow createRow(OID index, Variable[] values)
        throws UnsupportedOperationException
    {
      Snmp4jLogFileHandlerEntryRow row = new Snmp4jLogFileHandlerEntryRow(index, values);
     //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::createRow
     //--AgentGen END
      return row;
    }

    public void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::freeRow
     //--AgentGen END
    }
  }

  class Snmp4jLogFileHandlerEntryRow extends DefaultMOMutableRow2PC {
    public Snmp4jLogFileHandlerEntryRow(OID index, Variable[] values) {
      super(index, values);
    }

    public OctetString getSnmp4jLogFileHandlerPath() {
      return (OctetString) getValue(idxSnmp4jLogFileHandlerPath);
    }

    public void setSnmp4jLogFileHandlerPath(OctetString newValue) {
      setValue(idxSnmp4jLogFileHandlerPath, newValue);
    }

    public Integer32 getSnmp4jLogFileHandlerAppend() {
      return (Integer32) getValue(idxSnmp4jLogFileHandlerAppend);
    }

    public void setSnmp4jLogFileHandlerAppend(Integer32 newValue) {
      setValue(idxSnmp4jLogFileHandlerAppend, newValue);
    }

    public Integer32 getSnmp4jLogFileHandlerBufferedIO() {
      return (Integer32) getValue(idxSnmp4jLogFileHandlerBufferedIO);
    }

    public void setSnmp4jLogFileHandlerBufferedIO(Integer32 newValue) {
      setValue(idxSnmp4jLogFileHandlerBufferedIO, newValue);
    }

    public UnsignedInteger32 getSnmp4jLogFileHandlerBufferSize() {
      return (UnsignedInteger32) getValue(idxSnmp4jLogFileHandlerBufferSize);
    }

    public void setSnmp4jLogFileHandlerBufferSize(UnsignedInteger32 newValue) {
      setValue(idxSnmp4jLogFileHandlerBufferSize, newValue);
    }


     //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::RowFactory
     //--AgentGen END
  }

  class Snmp4jLogConsoleHandlerEntryRowFactory
        extends DefaultMOMutableRow2PCFactory
  {
    public Snmp4jLogConsoleHandlerEntryRowFactory() {}

    public MOTableRow createRow(OID index, Variable[] values)
        throws UnsupportedOperationException
    {
      Snmp4jLogConsoleHandlerEntryRow row =
          new Snmp4jLogConsoleHandlerEntryRow(index, values);
     //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::createRow

     //--AgentGen END
      return row;
    }

    public void freeRow(MOTableRow row) {
     //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::freeRow
     //--AgentGen END
    }
  }

  class Snmp4jLogConsoleHandlerEntryRow extends DefaultMOMutableRow2PC {
    public Snmp4jLogConsoleHandlerEntryRow(OID index, Variable[] values) {
      super(index, values);
    }

    public Integer32 getSnmp4jLogConsoleHandlerTarget() {
      return (Integer32) getValue(idxSnmp4jLogConsoleHandlerTarget);
    }

    public void setSnmp4jLogConsoleHandlerTarget(Integer32 newValue) {
      setValue(idxSnmp4jLogConsoleHandlerTarget, newValue);
    }


     //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::RowFactory
     //--AgentGen END
  }


//--AgentGen BEGIN=_METHODS

  private OctetString getLogSysDescr() {
    LogFactory logFactory = LogFactory.getLogFactory();
    if (logFactory == null) {
      return new OctetString();
    }
    return new OctetString(logFactory.getClass().getName());
  }

  public void lookupEvent(MOServerLookupEvent event) {
    if (event.getLookupResult() == this.snmp4jLogSysDescr) {
      this.snmp4jLogSysDescr.setValue(getLogSysDescr());
    }
    else if (event.getLookupResult() == this.snmp4jLogLoggerEntry) {
      updateLoggerTable();
    }
  }

  private Snmp4jLogLoggerRow createLoggerRow(int n, LogAdapter logger) {
    OID index = new OctetString(logger.getName()).toSubIndex(true);
    Variable[] row = new Variable[5];
    int i=0;
    row[i++] = new Integer32(n);
    row[i++] = new Integer32(logger.getLogLevel().getLevel());
    row[i++] = new Integer32(logger.getEffectiveLogLevel().getLevel());
    row[i++] = new Integer32(StorageType.volatile_);
    row[i++] = new Integer32(RowStatus.active);
    return new Snmp4jLogLoggerRow(index, row, n, logger);
  }

  public void updateLoggerTable() {
    snmp4jLogLoggerEntryModel.clear(NOT_ACTIVE_ROW_FILTER);
    if (LogFactory.getLogFactory() == null) {
      return;
    }
    Iterator loggers = LogFactory.getLogFactory().loggers();
    this.loggers = new HashMap();
    LogAdapter rootLogger = LogFactory.getLogFactory().getRootLogger();
    snmp4jLogLoggerEntryModel.addRow(createLoggerRow(1, rootLogger));
    while (loggers.hasNext()) {
      LogAdapter l = (LogAdapter) loggers.next();
      int i = 1;
      Integer index = (Integer) loggerNames2Index.get(l.getName());
      if (index == null) {
        i = nextLoggerIndex++;
        loggerNames2Index.put(l.getName(), new Integer(i));
      }
      else {
        i = index.intValue();
      }
      this.loggers.put(new Integer(i+1), l);
      snmp4jLogLoggerEntryModel.addRow(createLoggerRow(i+1, l));
    }
  }

  public void rowStatusChanged(RowStatusEvent event) {
    if (event.getTable().equals(snmp4jLogLoggerEntry)) {
      if ((event.getNewStatus() == RowStatus.active) ||
          (event.getNewStatus() == RowStatus.createAndGo)) {
        Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow) event.getRow();
        OctetString loggerName =
            new OctetString(r.getIndex().toByteArray());
        LogAdapter logAdapter =
            LogFactory.getLogFactory().getLogger(loggerName.toString());
        r.setLogAdapter(logAdapter);
        logAdapter.setLogLevel(
            new LogLevel(r.getSnmp4jLogLoggerLevel().getValue()));
      }
    }
  }

  public void rowChanged(MOTableRowEvent event) {
    if (event.getTable().equals(snmp4jLogLoggerEntry)) {
      if (event.getType() == MOTableRowEvent.UPDATED) {
        Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow) event.getRow();
        if (r.getLogAdapter() != null) {
          r.getLogAdapter().setLogLevel(
              new LogLevel(r.getSnmp4jLogLoggerLevel().getValue()));
        }
      }
    }
  }

  //--AgentGen END

  //--AgentGen BEGIN=_CLASSES

  public class Snmp4jLogLoggerRow extends Snmp4jLogLoggerEntryRow {

    private LogAdapter logger;
    private int n;

    protected Snmp4jLogLoggerRow(OID index, Variable[] values,
                                 int n, LogAdapter logger) {
      super(index, values);
      this.n = n;
      this.logger = logger;
    }

    public void setLogAdapter(LogAdapter logAdapter) {
      this.logger = logAdapter;
    }

    public LogAdapter getLogAdapter() {
      return logger;
    }

  }

  //--AgentGen END

//--AgentGen BEGIN=_END
//--AgentGen END
}