snmp.java

一个已经完善的极其方便的实现snmp的开发包

                          PDU pdu,
                          Target target,
                          TransportMapping transport) {
      this.userObject = userObject;
      this.listener = listener;
      this.retryCount = target.getRetries();
      this.pdu = pdu;
      this.target = (Target) target.clone();
      this.transport = transport;
    }

    private PendingRequest(PendingRequest other) {
      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;
      this.responseReceived = other.responseReceived;
      this.transport = other.transport;
    }

    protected void registerRequest(PduHandle handle) {

    }

    public void responseReceived() {
      this.responseReceived = true;
    }

    public synchronized void pduHandleAssigned(PduHandle handle, Object pdu) {
      if (key == null) {
        key = handle;
        pendingRequests.put(handle, this);
        registerRequest(handle);
        if (logger.isDebugEnabled()) {
          logger.debug("Running pending "+
                       ((listener instanceof SyncResponseListener) ?
                        "sync" : "async")+
                       " request with handle " + handle+
                       " and retry count left "+retryCount);
        }
        long delay = timeoutModel.getRetryTimeout(target.getRetries() -
                                                  retryCount,
                                                  target.getRetries(),
                                                  target.getTimeout());
        if ((!finished) && (!responseReceived)) {
          timer.schedule(this, delay);
        }
      }
    }

    /**
     * Process retries of a pending request.
     */
    public synchronized void run() {
      PduHandle m_key = key;
      PDU m_pdu = pdu;
      Target m_target = target;
      TransportMapping m_transport = transport;
      ResponseListener m_listener = listener;
      Object m_userObject = userObject;

      if ((m_key == null) || (m_pdu == null) || (m_target == null) ||
          (m_listener == null)) {
        if (logger.isDebugEnabled()) {
          logger.debug("PendingRequest canceled key="+m_key+", pdu="+m_pdu+
              ", target="+m_target+", transport="+m_transport+", listener="+
              m_listener);
        }
        return;
      }

      try {
        boolean retry;
        synchronized (pendingRequests) {
          retry = (!finished) && (retryCount > 0) && (!responseReceived);
        }
        if (retry) {
          try {
            PendingRequest nextRetry = new PendingRequest(this);
            sendMessage(m_pdu, m_target, m_transport, nextRetry);
          }
          catch (IOException ex) {
            finished = true;
            logger.error("Failed to send SNMP message to " + m_target +
                         ": " +
                         ex.getMessage());
            messageDispatcher.releaseStateReference(m_target.getVersion(),
                m_key);
            listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                  m_pdu, null, m_userObject,
                                                  ex));
          }
        }
        else if (!finished) {
          finished = true;
          pendingRequests.remove(m_key);

          if (!responseReceived) {
            // request timed out
            if (logger.isDebugEnabled()) {
              logger.debug("Request timed out: " + m_key.getTransactionID());
            }
            messageDispatcher.releaseStateReference(m_target.getVersion(),
                                                    m_key);
            listener.onResponse(new ResponseEvent(Snmp.this, null,
                                                  m_pdu, null, m_userObject));
          }
        }
        else {
          // make sure pending request is removed even if response listener
          // failed to call Snmp.cancel
          pendingRequests.remove(m_key);
        }
      }
      catch (RuntimeException ex) {
//        if (logger.isDebugEnabled()) {
          ex.printStackTrace();
//        }
        logger.error("Failed to process pending request " + m_key +
                     " because " + ex.getMessage(), ex);
        throw ex;
      }
      catch (Error er) {
        if (logger.isDebugEnabled()) {
          er.printStackTrace();
        }
        logger.fatal("Failed to process pending request " + m_key +
                     " because " + er.getMessage(), er);
        throw er;
      }
    }

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

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

    public int getMaxRepuestStatus() {
      return maxRequestStatus;
    }

    public boolean isResponseReceived() {
      return responseReceived;
    }

    /**
     * Cancels the request and clears all internal fields by setting them
     * to <code>null</code>.
     * @return
     *    <code>true</code> if cancellation was successful.
     */
    public boolean cancel(){
        boolean result = super.cancel();

        // free objects early
        key = null;
        pdu = null;
        target = null;
        transport = null;
        listener = null;
        userObject = null;

        return result;
    }

  }

  class AsyncPendingRequest extends PendingRequest {
    public AsyncPendingRequest(ResponseListener listener,
                               Object userObject,
                               PDU pdu,
                               Target target,
                               TransportMapping transport) {
      super(listener, userObject, pdu, target, transport);
    }

    protected void registerRequest(PduHandle handle) {
      AsyncRequestKey key = new AsyncRequestKey(super.pdu, super.listener);
      asyncRequests.put(key, handle);
    }
  }

  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();
    }
  }

  static class SyncResponseListener implements ResponseListener {

    private ResponseEvent response = null;

    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);
      notificationTransports.remove(tm);

      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());
    }
  }

}