snmp.java.svn-base

snmp hibernate 源码, 类似hibernate的映射.

      else {
        boolean intime = request.cancel();
        // remove pending request
        // (sync is not needed as request is already canceled)
        pendingRequests.remove(handle);
        if (intime) {
          // return report
          request.listener.onResponse(new ResponseEvent(this,
              e.getPeerAddress(),
              request.pdu,
              pdu,
              request.userObject));
        }
        else {
          // silently drop late report
          if (logger.isInfoEnabled()) {
            logger.info("Received late report from " +
                        e.getPeerAddress() +
                        " with request ID " + pdu.getRequestID());
          }
        }
      }
    }
  }


  /**
   * Removes a <code>CommandResponder</code> from this SNMP session.
   * @param listener
   *    a previously added <code>CommandResponder</code> instance.
   */
  public synchronized void removeCommandResponder(CommandResponder listener) {
    if (commandResponderListeners != null &&
        commandResponderListeners.contains(listener)) {
      Vector v = (Vector) commandResponderListeners.clone();
      v.removeElement(listener);
      commandResponderListeners = v;
    }
  }

  /**
   * Adds a <code>CommandResponder</code> to this SNMP session.
   * The command responder will then be informed about incoming SNMP PDUs of
   * any kind that are not related to any outstanding requests of this SNMP
   * session.
   *
   * @param listener
   *    the <code>CommandResponder</code> instance to be added.
   */
  public synchronized void addCommandResponder(CommandResponder listener) {
    Vector v = (commandResponderListeners == null) ?
        new Vector(2) : (Vector) commandResponderListeners.clone();
    if (!v.contains(listener)) {
      v.addElement(listener);
      commandResponderListeners = v;
    }
  }

  /**
   * Fires a <code>CommandResponderEvent</code> event to inform listeners about
   * a received PDU. If a listener has marked the event as processed further
   * listeners will not be informed about the event.
   * @param event
   *    a <code>CommandResponderEvent</code>.
   */
  protected void fireProcessPdu(CommandResponderEvent event) {
    if (commandResponderListeners != null) {
      Vector listeners = commandResponderListeners;
      int count = listeners.size();
      for (int i = 0; i < count; i++) {
        ((CommandResponder) listeners.elementAt(i)).processPdu(event);
        // if event is marked as processed the event is not forwarded to
        // remaining listeners
        if (event.isProcessed()) {
          return;
        }
      }
    }
  }

  /**
   * Gets the timeout model associated with this SNMP session.
   * @return
   *    a TimeoutModel instance (never <code>null</code>).
   * @see #setTimeoutModel(TimeoutModel timeoutModel)
   */
  public TimeoutModel getTimeoutModel() {
    return timeoutModel;
  }

  /**
   * Returns the report handler which is used internally to process reports
   * received from command responders.
   * @return
   *    the <code>ReportHandler</code> instance.
   * @since 1.6
   */
  public ReportHandler getReportHandler() {
    return reportHandler;
  }

  /**
   * Sets the timeout model for this SNMP session. The default timeout model
   * sends retries whenever the time specified by the <code>timeout</code>
   * parameter of the target has elapsed without a response beeing received for
   * the request. By specifying a different timeout model this behaviour can
   * be changed.
   * @param timeoutModel
   *    a <code>TimeoutModel</code> instance (must not be <code>null</code>).
   */
  public void setTimeoutModel(TimeoutModel timeoutModel) {
    if (timeoutModel == null) {
      throw new NullPointerException("Timeout model cannot be null");
    }
    this.timeoutModel = timeoutModel;
  }

  /**
   * Sets the report handler and overrides the default report handler.
   * @param reportHandler
   *    a <code>ReportHandler</code> instance which must not be
   *    <code>null</code>.
   * @since 1.6
   */
  public void setReportHandler(ReportHandler reportHandler) {
    if (reportHandler == null) {
      throw new IllegalArgumentException("ReportHandler must not be null");
    }
    this.reportHandler = reportHandler;
  }

  class PendingRequest extends TimerTask {

    private PduHandle key;
    private int retryCount;
    private ResponseListener listener;
    private Object userObject;

    private PDU pdu;
    private Target target;
    private TransportMapping transport;

    private int requestStatus = 0;
    // Maximum request status - allows to receive up to two reports and then
    // send the original request again. A value of 0 is used for discovery.
    private int maxRequestStatus = 2;

    private volatile boolean finished = false;


    public PendingRequest(PduHandle key,
                          ResponseListener listener,
                          Object userObject,
                          PDU pdu,
                          Target target,
                          TransportMapping transport) {
      this.key = key;
      this.userObject = userObject;
      this.listener = listener;
      this.retryCount = target.getRetries();
      this.pdu = pdu;
      this.target = target;
      this.transport = transport;
    }

    private PendingRequest(PendingRequest other) {
      this.key = other.key;
      this.userObject = other.userObject;
      this.listener = other.listener;
      this.retryCount = other.retryCount - 1;
      this.pdu = other.pdu;
      this.target = other.target;
      this.requestStatus = other.requestStatus;
    }

    /**
     * Process retries of a pending request.
     */
    public synchronized void run() {
      try {
        if ((!finished) && (retryCount > 0)) {
          try {
            sendMessage(pdu, target, transport);
            if (logger.isDebugEnabled()) {
              logger.debug("Running pending request (" + retryCount +
                           " left) with handle: " + key);
            }
            PendingRequest nextRetry = new PendingRequest(this);
            synchronized (sync) {
              pendingRequests.put(key, nextRetry);
              long delay =
                  timeoutModel.getRetryTimeout(target.getRetries() -
                                               (retryCount - 1),
                                               target.getRetries(),
                                               target.getTimeout());
              timer.schedule(nextRetry, delay);
            }
          }
          catch (IOException ex) {
            finished = true;
            logger.error("Failed to send SNMP message to " + target.toString() +
                         ": " +
                         ex.getMessage());
            messageDispatcher.releaseStateReference(target.getVersion(), key);
            listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                  pdu, null, userObject,
                                                  ex));
          }
        }
        else if (!finished) {
          finished = true;
          pendingRequests.remove(key);

          // request timed out
          if (logger.isDebugEnabled()) {
            logger.debug("Request timed out: " + key.getTransactionID());
          }
          messageDispatcher.releaseStateReference(target.getVersion(), key);
          listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                pdu, null, userObject));
        }
      }
      catch (RuntimeException ex) {
        logger.error("Failed to process pending request " + key +
                     " because " + ex.getMessage(), ex);
        throw ex;
      }
      catch (Error er) {
        logger.fatal("Failed to process pending request " + key +
                     " because " + er.getMessage(), er);
        throw er;
      }
    }

    public synchronized boolean setFinished() {
      boolean currentState = finished;
      this.finished = true;
      return currentState;
    }

    public void setMaxRepuestStatus(int maxRepuestStatus) {
      this.maxRequestStatus = maxRepuestStatus;
    }

    public int getMaxRepuestStatus() {
      return maxRequestStatus;
    }

  }

  static class AsyncRequestKey {
    private PDU request;
    private ResponseListener listener;

    public AsyncRequestKey(PDU request, ResponseListener listener) {
      this.request = request;
      this.listener = listener;
    }

    /**
     * Indicates whether some other object is "equal to" this one.
     *
     * @param obj the reference object with which to compare.
     * @return <code>true</code> if this object is the same as the obj argument;
     *   <code>false</code> otherwise.
     */
    public boolean equals(Object obj) {
      if (obj instanceof AsyncRequestKey) {
        AsyncRequestKey other = (AsyncRequestKey) obj;
        return (request.equals(other.request) && listener.equals(other.listener));
      }
      return false;
    }

    public int hashCode() {
      return request.hashCode();
    }
  }

  class SyncResponseListener implements ResponseListener {

    private ResponseEvent response = null;

    /**
     * onResponse
     *
     * @param event ResponseEvent
     */
    public synchronized void onResponse(ResponseEvent event) {
      this.response = event;
      this.notify();
    }

    public ResponseEvent getResponse() {
      return response;
    }

  }

  /**
   * The <code>NotificationDispatcher</code> dispatches traps, notifications,
   * and to registered listeners.
   *
   * @author Frank Fock
   * @version 1.6
   * @since 1.6
   */
  class NotificationDispatcher implements CommandResponder {
    // A mapping of transport addresses to transport mappings of notification
    // listeners
    private Hashtable notificationListeners = new Hashtable(10);
    private Hashtable notificationTransports = new Hashtable(10);

    protected NotificationDispatcher() {
    }

    public synchronized void addNotificationListener(Address listenAddress,
                                                     TransportMapping transport,
                                                     CommandResponder listener){
      notificationListeners.put(listenAddress, transport);
      notificationTransports.put(transport, listener);
    }

    public synchronized boolean
        removeNotificationListener(Address listenAddress)
    {
      TransportMapping tm =
          (TransportMapping)notificationListeners.remove(listenAddress);
      if (tm == null) {
        return false;
      }
      tm.removeTransportListener(messageDispatcher);

      try {
        tm.close();
      }
      catch (IOException ex) {
        logger.error(ex);
        if (logger.isDebugEnabled()) {
          ex.printStackTrace();
        }
      }
      return true;
    }

    public synchronized void closeAll() {
      notificationTransports.clear();
      for (Iterator it = notificationListeners.values().iterator();
           it.hasNext();) {
        TransportMapping tm = (TransportMapping) it.next();
        try {
          tm.close();
        }
        catch (IOException ex) {
          logger.error(ex);
          if (logger.isDebugEnabled()) {
            ex.printStackTrace();
          }
        }
      }
      notificationListeners.clear();
    }

    public synchronized void processPdu(CommandResponderEvent event) {
      CommandResponder listener = (CommandResponder)
          notificationTransports.get(event.getTransportMapping());
      if ((event.getPDU() != null) &&
          (event.getPDU().getType() == PDU.INFORM)) {
        // try to send INFORM response
        try {
          sendInformResponse(event);
        }
        catch (MessageException mex) {
          if (logger.isWarnEnabled()) {
            logger.warn("Failed to send response on INFORM PDU event (" +
                        event + "): " + mex.getMessage());
          }
        }
      }
      if (listener != null) {
        listener.processPdu(event);
      }
    }

    /**
     * Sends a RESPONSE PDU to the source address of a INFORM request.
     * @param event
     *    the <code>CommandResponderEvent</code> with the INFORM request.
     * @throws
     *    MessageException if the response could not be created and sent.
     */
    protected void sendInformResponse(CommandResponderEvent event) throws
        MessageException {
      PDU responsePDU = (PDU) event.getPDU().clone();
      responsePDU.setType(PDU.RESPONSE);
      responsePDU.setErrorStatus(PDU.noError);
      responsePDU.setErrorIndex(0);
      messageDispatcher.returnResponsePdu(event.getMessageProcessingModel(),
                                          event.getSecurityModel(),
                                          event.getSecurityName(),
                                          event.getSecurityLevel(),
                                          responsePDU,
                                          event.getMaxSizeResponsePDU(),
                                          event.getStateReference(),
                                          new StatusInformation());
    }
  }

}