defaultmoserver.java

你个snmp的源码

/*_############################################################################
  _##
  _##  SNMP4J-Agent - DefaultMOServer.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;

import java.util.*;

import org.snmp4j.log.*;
import org.snmp4j.smi.*;

/**
 * The default MO server implementation uses a sorted map for the managed object
 * registry.
 * @author Frank Fock
 * @version 1.0
 */
public class DefaultMOServer implements MOServer {

  private static final LogAdapter logger =
      LogFactory.getLogger(DefaultMOServer.class);

  private Set contexts;
  private SortedMap registry;
  private Map lockList;
  private Map lookupListener;
  private transient Vector contextListeners;


  public DefaultMOServer() {
    this.registry =
        Collections.synchronizedSortedMap(new TreeMap(new MOScopeComparator()));
    this.contexts = new LinkedHashSet(10);
    this.lockList = new Hashtable(10);
  }

  public ManagedObject lookup(MOQuery query) {
    SortedMap scope = registry.tailMap(query);
    Iterator it = scope.values().iterator();
    while (it.hasNext()) {
      Object o = it.next();
      if (o instanceof ManagedObject) {
        ManagedObject mo = (ManagedObject) o;
/* Not really interesting:
        if (logger.isDebugEnabled()) {
          logger.debug("Scanning managed object: " +
                       mo.getScope().getLowerBound() + "-" +
                       mo.getScope().getUpperBound() + " for " +
                       query);
        }
*/
        MOScope moScope = mo.getScope();
        if ((query.getScope().isOverlapping(moScope)) &&
            (query.matchesQuery(mo))) {
          fireLookupEvent(mo, query);
          return mo;
        }
      }
      else if (logger.isWarnEnabled()) {
        logger.warn("Object looked up is not a ManagedObject: "+o);
      }
    }
    return null;
  }

  protected void fireLookupEvent(ManagedObject mo, MOQuery query) {
    if (lookupListener != null) {
      List l = (List) lookupListener.get(mo);
      if (l != null) {
        MOServerLookupEvent event = new MOServerLookupEvent(this, mo, query);
        for (Iterator it = l.iterator(); it.hasNext(); ) {
          MOServerLookupListener item = (MOServerLookupListener) it.next();
          item.lookupEvent(event);
        }
      }
    }
  }

  public OctetString[] getContexts() {
    return (OctetString[]) contexts.toArray(new OctetString[0]);
  }

  public boolean isContextSupported(OctetString context) {
    if (context == null) {
      return true;
    }
    return contexts.contains(context);
  }

  public SortedMap getRegistry() {
    return registry;
  }

  public void register(ManagedObject mo, OctetString context)
      throws DuplicateRegistrationException
  {
    if (context == null) {
      /**@todo Implement correct duplicate registration check*/
      if (registry.get(mo.getScope()) != null) {
        throw new DuplicateRegistrationException(mo.getScope());
      }
      registry.put(mo.getScope(), mo);
      if (logger.isDebugEnabled()) {
        logger.debug("Registered MO "+mo+" in default context with scope "+
                     mo.getScope());
      }
    }
    else {
      DefaultMOContextScope scope =
          new DefaultMOContextScope(context, mo.getScope());
      if (registry.get(scope) != null) {
        throw new DuplicateRegistrationException(scope);
      }
      registry.put(scope, mo);
      if (logger.isDebugEnabled()) {
        logger.debug("Registered MO "+mo+" in context "+context+"with scope "+
                     scope);
      }
    }
  }

  public void unregister(ManagedObject mo, OctetString context) {
    if (context == null) {
      registry.remove(mo.getScope());
    }
    else {
      registry.remove(new DefaultMOContextScope(context, mo.getScope()));
    }
  }

  public void addContext(OctetString context) {
    contexts.add(context);
  }

  public void removeContext(OctetString context) {
    contexts.remove(context);
  }

  public synchronized void lock(Object owner, ManagedObject managedObject) {
    Lock lock;
    do {
      lock = (Lock) lockList.get(managedObject);
      if (lock == null) {
        lockList.put(managedObject, new Lock(owner));
        if (logger.isDebugEnabled()) {
          logger.debug("Acquired lock on "+managedObject+ " for "+owner);
        }
      }
      else if (lock.getOwner() != owner) {
        try {
          if (logger.isDebugEnabled()) {
            logger.debug("Waiting for lock on "+managedObject);
          }
          wait();
        }
        catch (InterruptedException ex) {
          /**@todo logging*/
          break;
        }
      }
      else {
        lock.add();
        if (logger.isDebugEnabled()) {
          logger.debug("Added lock on "+managedObject+ " for "+owner);
        }
        return;
      }
    }
    while (lock != null);
  }

  public synchronized void unlock(Object owner, ManagedObject managedObject) {
    Lock lock = (Lock) lockList.get(managedObject);
    if (lock == null) {
      return;
    }
    if (lock.getOwner() != owner) {
      if (logger.isDebugEnabled()) {
        logger.debug("Object '" + owner + "' is not owner of lock: " + lock);
      }
      return;
    }
    if (lock.remove()) {
      lockList.remove(managedObject);
      if (logger.isDebugEnabled()) {
        logger.debug("Removed lock on "+managedObject+ " by "+owner);
      }
      notify();
    }
  }

  public Iterator iterator() {
    return getRegistry().values().iterator();
  }

  public void addLookupListener(MOServerLookupListener listener,
                                ManagedObject mo) {
    if (lookupListener == null) {
      lookupListener = Collections.synchronizedMap(new HashMap());
    }
    List l = (List) lookupListener.get(mo);
    if (l == null) {
      l = Collections.synchronizedList(new LinkedList());
      lookupListener.put(mo, l);
    }
    l.add(listener);
  }

  public boolean removeLookupListener(MOServerLookupListener listener,
                                      ManagedObject mo) {
    if (lookupListener != null) {
      List l = (List) lookupListener.get(mo);
      if (l != null) {
        return l.remove(listener);
      }
    }
    return false;
  }

  public synchronized void addContextListener(ContextListener l) {
    if (contextListeners == null) {
      contextListeners = new Vector(2);
    }
    contextListeners.add(l);
  }

  public synchronized void removeContextListener(ContextListener l) {
    if (contextListeners != null) {
      contextListeners.remove(l);
    }
  }

  protected void fireContextChanged(ContextEvent event) {
    if (contextListeners != null) {
      Vector listeners = contextListeners;
      int count = listeners.size();
      for (int i = 0; i < count; i++) {
        ((ContextListener) listeners.elementAt(i)).contextChanged(event);
      }
    }
  }

  public String toString() {
    StringBuffer buf = new StringBuffer(getClass().getName());
    buf.append("[contexts="+contexts);
    buf.append("[keys={");
    for (Iterator it = registry.keySet().iterator(); it.hasNext();) {
      MOScope scope = (MOScope) it.next();
      buf.append(scope.getLowerBound());
      if (scope.isLowerIncluded()) {
        buf.append("+");
      }
      buf.append("-");
      buf.append(scope.getUpperBound());
      if (scope.isUpperIncluded()) {
        buf.append("+");
      }
      if (scope instanceof MOContextScope) {
        buf.append("("+((MOContextScope)scope).getContext()+")");
      }
      if (it.hasNext()) {
        buf.append(",");
      }
    }
    buf.append("}");
    buf.append(",registry="+registry);
    buf.append(",lockList="+lockList);
    buf.append(",lookupListener="+lookupListener);
    buf.append("]");
    return buf.toString();
  }

  class Lock {
    private Object owner;
    private long creationTime;
    private int count = 0;

    private Lock() {
      this.creationTime = System.currentTimeMillis();
      this.count = 0;
    }

    Lock(Object owner) {
      this();
      this.owner = owner;
    }

    public long getCreationTime() {
      return creationTime;
    }

    public int getCount() {
      return count;
    }

    public synchronized void add() {
      count++;
    }

    public synchronized boolean remove() {
      return (--count) <= 0;
    }

    public Object getOwner() {
      return owner;
    }
  }

}