snmprequest.java

你个snmp的源码

    int endIndex = repeaterStartIndex + (repeaterRowSize*rows);
    if ((startIndex < repeaterStartIndex) || (endIndex > subrequests.size())) {
      return null;
    }
    return subrequests.subList(startIndex, endIndex);
  }

  public int getMessageProcessingModel() {
    return this.requestEvent.getMessageProcessingModel();
  }

  public int getRepeaterCount() {
    PDU reqPDU = requestEvent.getPDU();
    return Math.max(reqPDU.size() - reqPDU.getNonRepeaters(), 0);
  }

  public boolean isPhaseComplete() {
    if (errorStatus == SnmpConstants.SNMP_ERROR_SUCCESS) {
      initSubRequests();
      for (Iterator it = subrequests.iterator(); it.hasNext(); ) {
        SubRequest subreq = (SubRequest) it.next();
        RequestStatus status = subreq.getStatus();
        if (status.getErrorStatus() != SnmpConstants.SNMP_ERROR_SUCCESS) {
          return true;
        }
        else if (!status.isPhaseComplete()) {
          return false;
        }
      }
    }
    if (requestEvent.getPDU().getType() == PDU.GETBULK) {
      SnmpSubRequestIterator it =
          new SnmpSubRequestIterator(subrequests.size(), 1);
      return !it.hasNext();
    }
    return true;
  }

  public boolean isBulkRequest() {
    return (requestEvent.getPDU().getType() == PDU.GETBULK);
  }

  /**
   *
   * @author Frank Fock
   * @version 1.0
   */
  public class SnmpSubRequestIterator implements SubRequestIterator {

    private int cursor = 0;
    private int increment = 1;
    private boolean noAppending;

    protected SnmpSubRequestIterator() {
      this.cursor = 0;
    }

    protected SnmpSubRequestIterator(int offset, int increment) {
      this.cursor = offset;
      this.increment = increment;
    }

    protected void setNoAppending(boolean noAppending) {
      this.noAppending = noAppending;
    }

    /**
     * hasNext
     *
     * @return boolean
     */
    public boolean hasNext() {
      synchronized (SnmpRequest.this) {
        PDU reqPDU = requestEvent.getPDU();
        if (reqPDU.getType() == PDU.GETBULK) {
          if (noAppending && (cursor >= subrequests.size())) {
            return false;
          }
          if (cursor < Math.min(reqPDU.size(), reqPDU.getNonRepeaters())) {
            return true;
          }
          else {
            if (cursor < reqPDU.getNonRepeaters() +
                reqPDU.getMaxRepetitions() * getRepeaterCount()) {
              List lastRow = lastRow(cursor);
              if (lastRow != null) {
                boolean allEndOfMibView = true;
                SubRequest sreq = null;
                for (Iterator it = lastRow.iterator(); it.hasNext(); ) {
                  sreq = (SubRequest) it.next();
                  if (sreq.getVariableBinding().getSyntax() !=
                      SMIConstants.EXCEPTION_END_OF_MIB_VIEW) {
                    allEndOfMibView = false;
                    break;
                  }
                }
                if (allEndOfMibView) {
                  // truncate request if already more elements are there
                  if ((sreq != null) &&
                      (sreq.getIndex() < subrequests.size())) {
                    int lastElementIndex = sreq.getIndex();
                    List tail = subrequests.subList(lastElementIndex + 1,
                        subrequests.size());
                    tail.clear();
                    tail = response.getVariableBindings().
                        subList(lastElementIndex + 1, response.size());
                    tail.clear();
                  }
                  return false;
                }
              }
              return (response.getBERLength() <
                      requestEvent.getMaxSizeResponsePDU());
            }
          }
          return false;
        }
        return (cursor < reqPDU.size());
      }
    }

    public SubRequest nextSubRequest() {
      if (!hasNext()) {
        throw new NoSuchElementException();
      }
      if ((requestEvent.getPDU().getType() == PDU.GETBULK) &&
          (cursor >= subrequests.size())) {
        while (cursor >= subrequests.size()) {
          addRepeaterSubRequest();
        }
      }
      SubRequest sreq = (SubRequest) subrequests.get(cursor);
      cursor += increment;
      return sreq;
    }

    public void remove() {
      throw new UnsupportedOperationException("Remove is not supported "+
                                              "on sub-requests");
    }

    public Object next() {
      return nextSubRequest();
    }

    public boolean equals(Object other) {
      if (other instanceof Request) {
        return ((Request)other).getTransactionID() == getTransactionID();
      }
      return false;
    }

    public int hashCode() {
      return getTransactionID();
    }
  }


  /**
   *
   * @author Frank Fock
   * @version 1.0
   */
  public class SnmpSubRequest
      implements org.snmp4j.agent.request.SnmpSubRequest, RequestStatusListener {

    private RequestStatus status;
    private VariableBinding vb;
    private Object undoValue;
    private MOScope scope;
    private ManagedObject targetMO;
    private MOQuery query;
    private int index;

    private volatile Object userObject;

    protected SnmpSubRequest(VariableBinding subrequest, int index) {
      this.vb = subrequest;
      this.index = index;
      switch (requestEvent.getPDU().getType()) {
        case PDU.GETBULK:
        case PDU.GETNEXT: {
          this.scope = getNextScope(this.vb.getOid());
          break;
        }
        default: {
          OID oid = this.vb.getOid();
          this.scope = new DefaultMOContextScope(getContext(),
                                                 oid, true, oid, true);
        }
      }
      status = new RequestStatus();
      status.addRequestStatusListener(this);
      if (logger.isDebugEnabled()) {
        logger.debug("Created subrequest "+index+" with scope "+scope+
                     " from "+subrequest);
      }
    }

    protected MOScope getNextScope(OID previousOID) {
      return new DefaultMOContextScope(getContext(), previousOID, false,
                                       null, false);
    }

    protected SnmpSubRequest(SnmpSubRequest predecessor, int index) {
      this((VariableBinding)predecessor.getVariableBinding().clone(), index);
//    Do not copy queries because they need to be updated externally only!
//    this.query = predecessor.getQuery();
    }

    public Request getRequest() {
      return SnmpRequest.this;
    }

    public RequestStatus getStatus() {
      return status;
    }

    public VariableBinding getVariableBinding() {
      return vb;
    }

    public void setStatus(RequestStatus status) {
      this.status = status;
    }

    public Object getUndoValue() {
      return undoValue;
    }

    public void setUndoValue(Object undoInformation) {
      this.undoValue = undoInformation;
    }

    public void requestStatusChanged(RequestStatusEvent event) {
      int newStatus = event.getStatus().getErrorStatus();
      setErrorStatus(newStatus);
      if (logger.isDebugEnabled() &&
          (newStatus != SnmpConstants.SNMP_ERROR_SUCCESS)) {
        new Exception("Error '"+
                      PDU.toErrorStatusText(event.getStatus().getErrorStatus())+
                      "' generated at: "+vb).printStackTrace();
      }
    }

    public MOScope getScope() {
      return scope;
    }

    public void completed() {
      status.setPhaseComplete(true);
    }

    public boolean hasError() {
      return getStatus().getErrorStatus() != SnmpConstants.SNMP_ERROR_SUCCESS;
    }

    public boolean isComplete() {
      return status.isPhaseComplete();
    }

    public void setTargetMO(ManagedObject managedObject) {
      this.targetMO = managedObject;
    }

    public ManagedObject getTargetMO() {
      return targetMO;
    }

    public SnmpRequest getSnmpRequest() {
      return SnmpRequest.this;
    }

    public void setErrorStatus(int errorStatus) {
      SnmpRequest.this.setErrorStatus(errorStatus);
    }

    public int getIndex() {
      return index;
    }

    public void setQuery(MOQuery query) {
      this.query = query;
    }

    public MOQuery getQuery() {
      return query;
    }

    public String toString() {
      return getClass().getName()+"[scope="+scope+
          ",vb="+vb+",status="+status+",query="+query+",index="+index+
          ",targetMO="+targetMO+"]";
    }

    public SubRequestIterator repetitions() {
      return repetitions(false);
    }

    private SubRequestIterator repetitions(boolean noAppending) {
      initSubRequests();
      if (isBulkRequest()) {
        int repeaters = requestEvent.getPDU().size() -
            requestEvent.getPDU().getNonRepeaters();
        SnmpSubRequestIterator it =
            new SnmpSubRequestIterator(getIndex(), repeaters);
        it.setNoAppending(noAppending);
        return it;
      }
      return new SubRequestIteratorSupport(Collections.EMPTY_LIST.iterator());
    }

    public void updateNextRepetition() {
      if (!isBulkRequest()) {
        return;
      }
      this.query = null;
      SubRequestIterator repetitions = repetitions(true);
      // skip this one
      repetitions.next();
      while (repetitions.hasNext()) {
        SnmpSubRequest nsreq = (SnmpSubRequest) repetitions.nextSubRequest();
        if ((getStatus().getErrorStatus() == PDU.noError) &&
            (!this.vb.isException())) {
          nsreq.query = null;
          nsreq.scope = getNextScope(this.vb.getOid());
          nsreq.getVariableBinding().setOid(this.vb.getOid());
        }
        else if (this.vb.isException()) {
            nsreq.query = null;
            nsreq.getVariableBinding().setOid(this.vb.getOid());
            nsreq.getVariableBinding().setVariable(this.vb.getVariable());
            nsreq.getStatus().setPhaseComplete(true);
        }
      }
    }

    public final int getErrorStatus() {
      return getStatus().getErrorStatus();
    }

    public Object getUserObject() {
      return userObject;
    }

    public void setUserObject(Object userObject) {
      this.userObject = userObject;
    }

  }

}