BUG-272: fix remoterpc-routingtable 68/7868/1
authorRobert Varga <rovarga@cisco.com>
Tue, 10 Jun 2014 11:56:19 +0000 (13:56 +0200)
committerRobert Varga <rovarga@cisco.com>
Tue, 10 Jun 2014 12:06:39 +0000 (14:06 +0200)
Organizes imports to fix issues reported.

Change-Id: Ib335fd1d3e199f332437423017deaf25acfd81e8
Signed-off-by: Robert Varga <rovarga@cisco.com>
opendaylight/md-sal/remoterpc-routingtable/implementation/src/main/java/org/opendaylight/controller/sal/connector/remoterpc/impl/RoutingTableImpl.java
opendaylight/md-sal/remoterpc-routingtable/implementation/src/test/java/org/opendaylight/controller/sal/connector/remoterpc/impl/RoutingTableImplTest.java

index d6b42fa..e242b0a 100644 (file)
 
 package org.opendaylight.controller.sal.connector.remoterpc.impl;
 
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableSet;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+
+import javax.transaction.HeuristicMixedException;
+import javax.transaction.HeuristicRollbackException;
+import javax.transaction.NotSupportedException;
+import javax.transaction.RollbackException;
+
 import org.apache.felix.dm.Component;
-import org.opendaylight.controller.clustering.services.*;
+import org.opendaylight.controller.clustering.services.CacheConfigException;
+import org.opendaylight.controller.clustering.services.CacheExistException;
+import org.opendaylight.controller.clustering.services.CacheListenerAddException;
+import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
+import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
+import org.opendaylight.controller.clustering.services.IClusterServices;
 import org.opendaylight.controller.sal.connector.remoterpc.api.RoutingTable;
 import org.opendaylight.controller.sal.connector.remoterpc.api.RoutingTableException;
 import org.opendaylight.controller.sal.connector.remoterpc.api.SystemException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.transaction.HeuristicMixedException;
-import javax.transaction.HeuristicRollbackException;
-import javax.transaction.NotSupportedException;
-import javax.transaction.RollbackException;
-import java.util.*;
-import java.util.concurrent.ConcurrentMap;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
 
 public class RoutingTableImpl<I, R> implements RoutingTable<I, R>, ICacheUpdateAware<I, R> {
 
-  private Logger log = LoggerFactory.getLogger(RoutingTableImpl.class);
+    private final Logger log = LoggerFactory.getLogger(RoutingTableImpl.class);
 
-  private IClusterGlobalServices clusterGlobalServices = null;
+    private IClusterGlobalServices clusterGlobalServices = null;
 
-  private ConcurrentMap<I,R> globalRpcCache = null;
-  private ConcurrentMap<I, LinkedHashSet<R>> rpcCache = null;  //need routes to ordered by insert-order
+    private ConcurrentMap<I,R> globalRpcCache = null;
+    private ConcurrentMap<I, LinkedHashSet<R>> rpcCache = null;  //need routes to ordered by insert-order
 
-  public static final String GLOBALRPC_CACHE = "remoterpc_routingtable.globalrpc_cache";
-  public static final String RPC_CACHE = "remoterpc_routingtable.rpc_cache";
+    public static final String GLOBALRPC_CACHE = "remoterpc_routingtable.globalrpc_cache";
+    public static final String RPC_CACHE = "remoterpc_routingtable.rpc_cache";
 
-  public RoutingTableImpl() {
-  }
-
-  @Override
-  public R getGlobalRoute(I routeId) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeId, "getGlobalRoute: routeId cannot be null!");
-    return globalRpcCache.get(routeId);
-  }
-
-  @Override
-  public void addGlobalRoute(I routeId, R route) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeId, "addGlobalRoute: routeId cannot be null!");
-    Preconditions.checkNotNull(route, "addGlobalRoute: route cannot be null!");
-    try {
-
-      log.debug("addGlobalRoute: adding  a new route with id[{}] and value [{}]", routeId, route);
-      clusterGlobalServices.tbegin();
-      if (globalRpcCache.putIfAbsent(routeId, route) != null) {
-        throw new DuplicateRouteException(" There is already existing route " + routeId);
-      }
-      clusterGlobalServices.tcommit();
-
-    } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
-      throw new RoutingTableException("Transaction error - while trying to create route id="
-          + routeId + "with route" + route, e);
-    } catch (javax.transaction.SystemException e) {
-      throw new SystemException("System error occurred - while trying to create with value", e);
+    public RoutingTableImpl() {
     }
 
-  }
+    @Override
+    public R getGlobalRoute(final I routeId) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeId, "getGlobalRoute: routeId cannot be null!");
+        return globalRpcCache.get(routeId);
+    }
 
-  @Override
-  public void removeGlobalRoute(I routeId) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeId, "removeGlobalRoute: routeId cannot be null!");
-    try {
-      log.debug("removeGlobalRoute: removing  a new route with id [{}]", routeId);
+    @Override
+    public void addGlobalRoute(final I routeId, final R route) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeId, "addGlobalRoute: routeId cannot be null!");
+        Preconditions.checkNotNull(route, "addGlobalRoute: route cannot be null!");
+        try {
+
+            log.debug("addGlobalRoute: adding  a new route with id[{}] and value [{}]", routeId, route);
+            clusterGlobalServices.tbegin();
+            if (globalRpcCache.putIfAbsent(routeId, route) != null) {
+                throw new DuplicateRouteException(" There is already existing route " + routeId);
+            }
+            clusterGlobalServices.tcommit();
+
+        } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
+            throw new RoutingTableException("Transaction error - while trying to create route id="
+                    + routeId + "with route" + route, e);
+        } catch (javax.transaction.SystemException e) {
+            throw new SystemException("System error occurred - while trying to create with value", e);
+        }
 
-      clusterGlobalServices.tbegin();
-      globalRpcCache.remove(routeId);
-      clusterGlobalServices.tcommit();
+    }
 
-    } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
-      throw new RoutingTableException("Transaction error - while trying to remove route id="
-          + routeId, e);
-    } catch (javax.transaction.SystemException e) {
-      throw new SystemException("System error occurred - while trying to remove with value", e);
+    @Override
+    public void removeGlobalRoute(final I routeId) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeId, "removeGlobalRoute: routeId cannot be null!");
+        try {
+            log.debug("removeGlobalRoute: removing  a new route with id [{}]", routeId);
+
+            clusterGlobalServices.tbegin();
+            globalRpcCache.remove(routeId);
+            clusterGlobalServices.tcommit();
+
+        } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
+            throw new RoutingTableException("Transaction error - while trying to remove route id="
+                    + routeId, e);
+        } catch (javax.transaction.SystemException e) {
+            throw new SystemException("System error occurred - while trying to remove with value", e);
+        }
     }
-  }
 
 
-  @Override
-  public Set<R> getRoutes(I routeId) {
-    Preconditions.checkNotNull(routeId, "getRoutes: routeId cannot be null!");
-    Set<R> routes = rpcCache.get(routeId);
+    @Override
+    public Set<R> getRoutes(final I routeId) {
+        Preconditions.checkNotNull(routeId, "getRoutes: routeId cannot be null!");
+        Set<R> routes = rpcCache.get(routeId);
 
-    if (routes == null) return Collections.emptySet();
+        if (routes == null) {
+            return Collections.emptySet();
+        }
 
-    return ImmutableSet.copyOf(routes);
-  }
+        return ImmutableSet.copyOf(routes);
+    }
 
 
 
-  public R getLastAddedRoute(I routeId) {
+    @Override
+    public R getLastAddedRoute(final I routeId) {
 
-    Set<R> routes = getRoutes(routeId);
+        Set<R> routes = getRoutes(routeId);
 
-    if (routes.isEmpty()) return null;
+        if (routes.isEmpty()) {
+            return null;
+        }
 
-    R route = null;
-    Iterator<R> iter = routes.iterator();
-    while (iter.hasNext())
-      route = iter.next();
+        R route = null;
+        Iterator<R> iter = routes.iterator();
+        while (iter.hasNext()) {
+            route = iter.next();
+        }
 
-    return route;
-  }
+        return route;
+    }
 
-  @Override
-  public void addRoute(I routeId, R route)  throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeId, "addRoute: routeId cannot be null");
-    Preconditions.checkNotNull(route, "addRoute: route cannot be null");
+    @Override
+    public void addRoute(final I routeId, final R route)  throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeId, "addRoute: routeId cannot be null");
+        Preconditions.checkNotNull(route, "addRoute: route cannot be null");
+
+        try{
+            clusterGlobalServices.tbegin();
+            log.debug("addRoute: adding a route with k/v [{}/{}]", routeId, route);
+            threadSafeAdd(routeId, route);
+            clusterGlobalServices.tcommit();
+
+        } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
+            throw new RoutingTableException("Transaction error - while trying to remove route id="
+                    + routeId, e);
+        } catch (javax.transaction.SystemException e) {
+            throw new SystemException("System error occurred - while trying to remove with value", e);
+        }
+    }
 
-    try{
-      clusterGlobalServices.tbegin();
-      log.debug("addRoute: adding a route with k/v [{}/{}]", routeId, route);
-      threadSafeAdd(routeId, route);
-      clusterGlobalServices.tcommit();
+    @Override
+    public void addRoutes(final Set<I> routeIds, final R route) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeIds, "addRoutes: routeIds must not be null");
+        for (I routeId : routeIds){
+            addRoute(routeId, route);
+        }
+    }
 
-    } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
-      throw new RoutingTableException("Transaction error - while trying to remove route id="
-          + routeId, e);
-    } catch (javax.transaction.SystemException e) {
-      throw new SystemException("System error occurred - while trying to remove with value", e);
+    @Override
+    public void removeRoute(final I routeId, final R route) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeId, "removeRoute: routeId cannot be null!");
+        Preconditions.checkNotNull(route, "removeRoute: route cannot be null!");
+
+        LinkedHashSet<R> routes = rpcCache.get(routeId);
+        if (routes == null) {
+            return;
+        }
+
+        try {
+            log.debug("removeRoute: removing  a new route with k/v [{}/{}]", routeId, route);
+
+            clusterGlobalServices.tbegin();
+            threadSafeRemove(routeId, route);
+            clusterGlobalServices.tcommit();
+
+        } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
+            throw new RoutingTableException("Transaction error - while trying to remove route id="
+                    + routeId, e);
+        } catch (javax.transaction.SystemException e) {
+            throw new SystemException("System error occurred - while trying to remove with value", e);
+        }
     }
-  }
 
-  @Override
-  public void addRoutes(Set<I> routeIds, R route) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeIds, "addRoutes: routeIds must not be null");
-    for (I routeId : routeIds){
-      addRoute(routeId, route);
+    @Override
+    public void removeRoutes(final Set<I> routeIds, final R route) throws RoutingTableException, SystemException {
+        Preconditions.checkNotNull(routeIds, "removeRoutes: routeIds must not be null");
+        for (I routeId : routeIds){
+            removeRoute(routeId, route);
+        }
     }
-  }
 
-  @Override
-  public void removeRoute(I routeId, R route) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeId, "removeRoute: routeId cannot be null!");
-    Preconditions.checkNotNull(route, "removeRoute: route cannot be null!");
+    /**
+     * This method guarantees that no 2 thread over write each other's changes.
+     * Just so that we dont end up in infinite loop, it tries for 100 times then throw
+     */
+    private void threadSafeAdd(final I routeId, final R route) {
+
+        for (int i=0;i<100;i++){
+
+            LinkedHashSet<R> updatedRoutes = new LinkedHashSet<>();
+            updatedRoutes.add(route);
+            LinkedHashSet<R> oldRoutes = rpcCache.putIfAbsent(routeId, updatedRoutes);
+            if (oldRoutes == null) {
+                return;
+            }
+
+            updatedRoutes = new LinkedHashSet<>(oldRoutes);
+            updatedRoutes.add(route);
+
+            if (rpcCache.replace(routeId, oldRoutes, updatedRoutes)) {
+                return;
+            }
+        }
+        //the method did not already return means it failed to add route in 10 attempts
+        throw new IllegalStateException("Failed to add route [" + routeId + "]");
+    }
 
-    LinkedHashSet<R> routes = rpcCache.get(routeId);
-    if (routes == null) return;
+    /**
+     * This method guarantees that no 2 thread over write each other's changes.
+     * Just so that we dont end up in infinite loop, it tries for 10 times then throw
+     */
+    private void threadSafeRemove(final I routeId, final R route) {
+        LinkedHashSet<R> updatedRoutes = null;
+        for (int i=0;i<10;i++){
+            LinkedHashSet<R> oldRoutes = rpcCache.get(routeId);
+
+            // if route to be deleted is the only entry in the set then remove routeId from the cache
+            if ((oldRoutes.size() == 1) && oldRoutes.contains(route)){
+                rpcCache.remove(routeId);
+                return;
+            }
+
+            // if there are multiple routes for this routeId, remove the route to be deleted only from the set.
+            updatedRoutes = new LinkedHashSet<>(oldRoutes);
+            updatedRoutes.remove(route);
+            if (rpcCache.replace(routeId, oldRoutes, updatedRoutes)) {
+                return;
+            }
+
+        }
+        //the method did not already return means it failed to remove route in 10 attempts
+        throw new IllegalStateException("Failed to remove route [" + routeId + "]");
+    }
 
-    try {
-      log.debug("removeRoute: removing  a new route with k/v [{}/{}]", routeId, route);
 
-      clusterGlobalServices.tbegin();
-      threadSafeRemove(routeId, route);
-      clusterGlobalServices.tcommit();
+    //    /**
+    //     * @deprecated doesn't do anything will be removed once listeners used
+    //     *             whiteboard pattern Registers listener for sending any change
+    //     *             notification
+    //     * @param listener
+    //     */
+    //    @Override
+    //    public void registerRouteChangeListener(RouteChangeListener listener) {
+    //
+    //    }
+
+    //    public void setRouteChangeListener(RouteChangeListener rcl) {
+    //        if(rcl != null){
+    //            routeChangeListeners.add(rcl);
+    //        }else{
+    //            log.warn("setRouteChangeListener called with null listener");
+    //        }
+    //    }
+    //
+    //    public void unSetRouteChangeListener(RouteChangeListener rcl) {
+    //        if(rcl != null){
+    //         routeChangeListeners.remove(rcl);
+    //        }else{
+    //            log.warn("unSetRouteChangeListener called with null listener");
+    //        }
+    //    }
+
+    /**
+     * Returning the set of route change listeners for Unit testing Note: the
+     * package scope is default
+     *
+     * @return List of registered RouteChangeListener<I,R> listeners
+     */
+    //    Set<RouteChangeListener> getRegisteredRouteChangeListeners() {
+    //        return routeChangeListeners;
+    //    }
+    public void setClusterGlobalServices(final IClusterGlobalServices clusterGlobalServices) {
+        this.clusterGlobalServices = clusterGlobalServices;
+    }
 
-    } catch (NotSupportedException | HeuristicRollbackException | RollbackException | HeuristicMixedException e) {
-      throw new RoutingTableException("Transaction error - while trying to remove route id="
-          + routeId, e);
-    } catch (javax.transaction.SystemException e) {
-      throw new SystemException("System error occurred - while trying to remove with value", e);
+    public void unsetClusterGlobalServices(final IClusterGlobalServices clusterGlobalServices) {
+        if ((clusterGlobalServices != null) && (this.clusterGlobalServices.equals(clusterGlobalServices))) {
+            this.clusterGlobalServices = null;
+        }
     }
-  }
 
-  @Override
-  public void removeRoutes(Set<I> routeIds, R route) throws RoutingTableException, SystemException {
-    Preconditions.checkNotNull(routeIds, "removeRoutes: routeIds must not be null");
-    for (I routeId : routeIds){
-      removeRoute(routeId, route);
+    /**
+     * Finds OR Creates clustered cache for Global RPCs
+     *
+     * @throws CacheExistException       -- cluster global services exception when cache exist
+     * @throws CacheConfigException      -- cluster global services exception during cache config
+     * @throws CacheListenerAddException -- cluster global services exception during adding of listener
+     */
+
+    @SuppressWarnings("unchecked")
+    void findOrCreateGlobalRpcCache() throws CacheExistException, CacheConfigException,
+    CacheListenerAddException {
+        // TBD: HOW DO WE DECIDE ON PROPERTIES OF THE CACHE i.e. what duration it
+        // should be caching?
+
+        // let us check here if the cache already exists -- if so don't create
+        if (!clusterGlobalServices.existCache(GLOBALRPC_CACHE)) {
+
+            globalRpcCache = (ConcurrentMap<I,R>) clusterGlobalServices.createCache(GLOBALRPC_CACHE,
+                    EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
+            log.debug("Cache created [{}] ", GLOBALRPC_CACHE);
+
+        } else {
+            globalRpcCache = (ConcurrentMap<I,R>) clusterGlobalServices.getCache(GLOBALRPC_CACHE);
+            log.debug("Cache exists [{}] ", GLOBALRPC_CACHE);
+        }
     }
-  }
 
-  /**
-   * This method guarantees that no 2 thread over write each other's changes.
-   * Just so that we dont end up in infinite loop, it tries for 100 times then throw
-   */
-  private void threadSafeAdd(I routeId, R route) {
+    /**
+     * Finds OR Creates clustered cache for Routed RPCs
+     *
+     * @throws CacheExistException       -- cluster global services exception when cache exist
+     * @throws CacheConfigException      -- cluster global services exception during cache config
+     * @throws CacheListenerAddException -- cluster global services exception during adding of listener
+     */
+
+    @SuppressWarnings("unchecked")
+    void findOrCreateRpcCache() throws CacheExistException, CacheConfigException,
+    CacheListenerAddException {
+        // TBD: HOW DO WE DECIDE ON PROPERTIES OF THE CACHE i.e. what duration it
+        // should be caching?
+
+        if (clusterGlobalServices.existCache(RPC_CACHE)){
+            rpcCache = (ConcurrentMap<I,LinkedHashSet<R>>) clusterGlobalServices.getCache(RPC_CACHE);
+            log.debug("Cache exists [{}] ", RPC_CACHE);
+            return;
+        }
+
+        //cache doesnt exist, create one
+        rpcCache = (ConcurrentMap<I,LinkedHashSet<R>>) clusterGlobalServices.createCache(RPC_CACHE,
+                EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
+        log.debug("Cache created [{}] ", RPC_CACHE);
+    }
 
-    for (int i=0;i<100;i++){
 
-      LinkedHashSet<R> updatedRoutes = new LinkedHashSet<>();
-      updatedRoutes.add(route);
-      LinkedHashSet<R> oldRoutes = rpcCache.putIfAbsent(routeId, updatedRoutes);
-      if (oldRoutes == null) return;
+    /**
+     * Function called by the dependency manager when all the required
+     * dependencies are satisfied
+     */
+    void init(final Component c) {
+        try {
 
-      updatedRoutes = new LinkedHashSet<>(oldRoutes);
-      updatedRoutes.add(route);
+            findOrCreateGlobalRpcCache();
+            findOrCreateRpcCache();
 
-      if (rpcCache.replace(routeId, oldRoutes, updatedRoutes)) return;
+        } catch (CacheExistException|CacheConfigException|CacheListenerAddException e) {
+            throw new IllegalStateException("could not construct routing table cache");
+        }
     }
-    //the method did not already return means it failed to add route in 10 attempts
-    throw new IllegalStateException("Failed to add route [" + routeId + "]");
-  }
-
-  /**
-   * This method guarantees that no 2 thread over write each other's changes.
-   * Just so that we dont end up in infinite loop, it tries for 10 times then throw
-   */
-  private void threadSafeRemove(I routeId, R route) {
-    LinkedHashSet<R> updatedRoutes = null;
-    for (int i=0;i<10;i++){
-      LinkedHashSet<R> oldRoutes = rpcCache.get(routeId);
-
-      // if route to be deleted is the only entry in the set then remove routeId from the cache
-      if ((oldRoutes.size() == 1) && oldRoutes.contains(route)){
-        rpcCache.remove(routeId);
-        return;
-      }
-
-      // if there are multiple routes for this routeId, remove the route to be deleted only from the set.
-      updatedRoutes = new LinkedHashSet<>(oldRoutes);
-      updatedRoutes.remove(route);
-      if (rpcCache.replace(routeId, oldRoutes, updatedRoutes)) return;
 
+    /**
+     * Useful for unit testing <note>It has package
+     * scope</note>
+     */
+    ConcurrentMap<I, R> getGlobalRpcCache() {
+        return this.globalRpcCache;
     }
-    //the method did not already return means it failed to remove route in 10 attempts
-    throw new IllegalStateException("Failed to remove route [" + routeId + "]");
-  }
-
-
-//    /**
-//     * @deprecated doesn't do anything will be removed once listeners used
-//     *             whiteboard pattern Registers listener for sending any change
-//     *             notification
-//     * @param listener
-//     */
-//    @Override
-//    public void registerRouteChangeListener(RouteChangeListener listener) {
-//
-//    }
-
-//    public void setRouteChangeListener(RouteChangeListener rcl) {
-//        if(rcl != null){
-//            routeChangeListeners.add(rcl);
-//        }else{
-//            log.warn("setRouteChangeListener called with null listener");
-//        }
-//    }
-//
-//    public void unSetRouteChangeListener(RouteChangeListener rcl) {
-//        if(rcl != null){
-//         routeChangeListeners.remove(rcl);
-//        }else{
-//            log.warn("unSetRouteChangeListener called with null listener");
-//        }
-//    }
-
-  /**
-   * Returning the set of route change listeners for Unit testing Note: the
-   * package scope is default
-   *
-   * @return List of registered RouteChangeListener<I,R> listeners
-   */
-//    Set<RouteChangeListener> getRegisteredRouteChangeListeners() {
-//        return routeChangeListeners;
-//    }
-  public void setClusterGlobalServices(IClusterGlobalServices clusterGlobalServices) {
-    this.clusterGlobalServices = clusterGlobalServices;
-  }
-
-  public void unsetClusterGlobalServices(IClusterGlobalServices clusterGlobalServices) {
-    if ((clusterGlobalServices != null) && (this.clusterGlobalServices.equals(clusterGlobalServices))) {
-      this.clusterGlobalServices = null;
-    }
-  }
-
-  /**
-   * Finds OR Creates clustered cache for Global RPCs
-   *
-   * @throws CacheExistException       -- cluster global services exception when cache exist
-   * @throws CacheConfigException      -- cluster global services exception during cache config
-   * @throws CacheListenerAddException -- cluster global services exception during adding of listener
-   */
-
-  void findOrCreateGlobalRpcCache() throws CacheExistException, CacheConfigException,
-      CacheListenerAddException {
-    // TBD: HOW DO WE DECIDE ON PROPERTIES OF THE CACHE i.e. what duration it
-    // should be caching?
-
-    // let us check here if the cache already exists -- if so don't create
-    if (!clusterGlobalServices.existCache(GLOBALRPC_CACHE)) {
-
-      globalRpcCache = (ConcurrentMap<I,R>) clusterGlobalServices.createCache(GLOBALRPC_CACHE,
-          EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-      log.debug("Cache created [{}] ", GLOBALRPC_CACHE);
-
-    } else {
-      globalRpcCache = (ConcurrentMap<I,R>) clusterGlobalServices.getCache(GLOBALRPC_CACHE);
-      log.debug("Cache exists [{}] ", GLOBALRPC_CACHE);
-    }
-  }
-
-  /**
-   * Finds OR Creates clustered cache for Routed RPCs
-   *
-   * @throws CacheExistException       -- cluster global services exception when cache exist
-   * @throws CacheConfigException      -- cluster global services exception during cache config
-   * @throws CacheListenerAddException -- cluster global services exception during adding of listener
-   */
-
-  void findOrCreateRpcCache() throws CacheExistException, CacheConfigException,
-      CacheListenerAddException {
-    // TBD: HOW DO WE DECIDE ON PROPERTIES OF THE CACHE i.e. what duration it
-    // should be caching?
-
-    if (clusterGlobalServices.existCache(RPC_CACHE)){
-      rpcCache = (ConcurrentMap<I,LinkedHashSet<R>>) clusterGlobalServices.getCache(RPC_CACHE);
-      log.debug("Cache exists [{}] ", RPC_CACHE);
-      return;
-    }
-
-    //cache doesnt exist, create one
-    rpcCache = (ConcurrentMap<I,LinkedHashSet<R>>) clusterGlobalServices.createCache(RPC_CACHE,
-          EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL));
-    log.debug("Cache created [{}] ", RPC_CACHE);
-  }
-
-
-  /**
-   * Function called by the dependency manager when all the required
-   * dependencies are satisfied
-   */
-  void init(Component c) {
-    try {
 
-      findOrCreateGlobalRpcCache();
-      findOrCreateRpcCache();
-
-    } catch (CacheExistException|CacheConfigException|CacheListenerAddException e) {
-      throw new IllegalStateException("could not construct routing table cache");
+    /**
+     * Useful for unit testing <note>It has package
+     * scope</note>
+     */
+    ConcurrentMap<I, LinkedHashSet<R>> getRpcCache() {
+        return this.rpcCache;
     }
-  }
-
-  /**
-   * Useful for unit testing <note>It has package
-   * scope</note>
-   */
-  ConcurrentMap getGlobalRpcCache() {
-    return this.globalRpcCache;
-  }
-
-  /**
-   * Useful for unit testing <note>It has package
-   * scope</note>
-   */
-  ConcurrentMap getRpcCache() {
-    return this.rpcCache;
-  }
-
-  /**
-   * This is used from integration test NP rest API to check out the result of the
-   * cache population
-   * <Note> For testing purpose only-- use it wisely</Note>
-   *
-   * @return
-   */
-  public String dumpGlobalRpcCache() {
-    Set<Map.Entry<I, R>> cacheEntrySet = this.globalRpcCache.entrySet();
-    StringBuilder sb = new StringBuilder();
-    for (Map.Entry<I, R> entry : cacheEntrySet) {
-      sb.append("Key:").append(entry.getKey()).append("---->Value:")
-          .append((entry.getValue() != null) ? entry.getValue() : "null")
-          .append("\n");
+
+    /**
+     * This is used from integration test NP rest API to check out the result of the
+     * cache population
+     * <Note> For testing purpose only-- use it wisely</Note>
+     *
+     * @return
+     */
+    public String dumpGlobalRpcCache() {
+        Set<Map.Entry<I, R>> cacheEntrySet = this.globalRpcCache.entrySet();
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<I, R> entry : cacheEntrySet) {
+            sb.append("Key:").append(entry.getKey()).append("---->Value:")
+            .append((entry.getValue() != null) ? entry.getValue() : "null")
+            .append("\n");
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
-
-  public String dumpRpcCache() {
-    Set<Map.Entry<I, LinkedHashSet<R>>> cacheEntrySet = this.rpcCache.entrySet();
-    StringBuilder sb = new StringBuilder();
-    for (Map.Entry<I, LinkedHashSet<R>> entry : cacheEntrySet) {
-      sb.append("Key:").append(entry.getKey()).append("---->Value:")
-          .append((entry.getValue() != null) ? entry.getValue() : "null")
-          .append("\n");
+
+    public String dumpRpcCache() {
+        Set<Map.Entry<I, LinkedHashSet<R>>> cacheEntrySet = this.rpcCache.entrySet();
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<I, LinkedHashSet<R>> entry : cacheEntrySet) {
+            sb.append("Key:").append(entry.getKey()).append("---->Value:")
+            .append((entry.getValue() != null) ? entry.getValue() : "null")
+            .append("\n");
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
-  /**
-   * Invoked when a new entry is available in the cache, the key is only
-   * provided, the value will come as an entryUpdate invocation
-   *
-   * @param key         Key for the entry just created
-   * @param cacheName   name of the cache for which update has been received
-   * @param originLocal true if the event is generated from this node
-   */
-  @Override
-  public void entryCreated(I key, String cacheName, boolean originLocal) {
-    // TBD: do we require this.
-    if (log.isDebugEnabled()) {
-      log.debug("RoutingTableUpdates: entryCreated  routeId = " + key + " cacheName=" + cacheName);
+    /**
+     * Invoked when a new entry is available in the cache, the key is only
+     * provided, the value will come as an entryUpdate invocation
+     *
+     * @param key         Key for the entry just created
+     * @param cacheName   name of the cache for which update has been received
+     * @param originLocal true if the event is generated from this node
+     */
+    @Override
+    public void entryCreated(final I key, final String cacheName, final boolean originLocal) {
+        // TBD: do we require this.
+        if (log.isDebugEnabled()) {
+            log.debug("RoutingTableUpdates: entryCreated  routeId = " + key + " cacheName=" + cacheName);
+        }
     }
-  }
-
-  /**
-   * Called anytime a given entry is updated
-   *
-   * @param key         Key for the entry modified
-   * @param new_value   the new value the key will have
-   * @param cacheName   name of the cache for which update has been received
-   * @param originLocal true if the event is generated from this node
-   */
-  @Override
-  public void entryUpdated(I key, R new_value, String cacheName, boolean originLocal) {
-    if (log.isDebugEnabled()) {
-      log.debug("RoutingTableUpdates: entryUpdated  routeId = " + key + ",value = " + new_value
-          + " ,cacheName=" + cacheName + " originLocal=" + originLocal);
+
+    /**
+     * Called anytime a given entry is updated
+     *
+     * @param key         Key for the entry modified
+     * @param new_value   the new value the key will have
+     * @param cacheName   name of the cache for which update has been received
+     * @param originLocal true if the event is generated from this node
+     */
+    @Override
+    public void entryUpdated(final I key, final R new_value, final String cacheName, final boolean originLocal) {
+        if (log.isDebugEnabled()) {
+            log.debug("RoutingTableUpdates: entryUpdated  routeId = " + key + ",value = " + new_value
+                    + " ,cacheName=" + cacheName + " originLocal=" + originLocal);
+        }
+        //        if (!originLocal) {
+        //            for (RouteChangeListener rcl : routeChangeListeners) {
+        //                rcl.onRouteUpdated(key, new_value);
+        //            }
+        //        }
     }
-//        if (!originLocal) {
-//            for (RouteChangeListener rcl : routeChangeListeners) {
-//                rcl.onRouteUpdated(key, new_value);
-//            }
-//        }
-  }
-
-  /**
-   * Called anytime a given key is removed from the ConcurrentHashMap we are
-   * listening to.
-   *
-   * @param key         Key of the entry removed
-   * @param cacheName   name of the cache for which update has been received
-   * @param originLocal true if the event is generated from this node
-   */
-  @Override
-  public void entryDeleted(I key, String cacheName, boolean originLocal) {
-    if (log.isDebugEnabled()) {
-      log.debug("RoutingTableUpdates: entryUpdated  routeId = " + key + " local = " + originLocal
-          + " cacheName=" + cacheName + " originLocal=" + originLocal);
+
+    /**
+     * Called anytime a given key is removed from the ConcurrentHashMap we are
+     * listening to.
+     *
+     * @param key         Key of the entry removed
+     * @param cacheName   name of the cache for which update has been received
+     * @param originLocal true if the event is generated from this node
+     */
+    @Override
+    public void entryDeleted(final I key, final String cacheName, final boolean originLocal) {
+        if (log.isDebugEnabled()) {
+            log.debug("RoutingTableUpdates: entryUpdated  routeId = " + key + " local = " + originLocal
+                    + " cacheName=" + cacheName + " originLocal=" + originLocal);
+        }
+        //        if (!originLocal) {
+        //            for (RouteChangeListener rcl : routeChangeListeners) {
+        //                rcl.onRouteDeleted(key);
+        //            }
+        //        }
     }
-//        if (!originLocal) {
-//            for (RouteChangeListener rcl : routeChangeListeners) {
-//                rcl.onRouteDeleted(key);
-//            }
-//        }
-  }
-}
\ No newline at end of file
+}
index 0987df5..1ff49c1 100644 (file)
@@ -8,7 +8,22 @@
 
 package org.opendaylight.controller.sal.connector.remoterpc.impl;
 
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
 import junit.framework.Assert;
+
 import org.apache.felix.dm.Component;
 import org.junit.After;
 import org.junit.Before;
@@ -17,314 +32,303 @@ import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
 import org.opendaylight.controller.clustering.services.IClusterServices;
 import org.opendaylight.controller.sal.connector.api.RpcRouter;
 import org.opendaylight.controller.sal.connector.remoterpc.api.RoutingTable;
-import org.opendaylight.controller.sal.connector.remoterpc.api.RoutingTableException;
-import org.opendaylight.controller.sal.connector.remoterpc.api.SystemException;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
 
-import java.net.URI;
-import java.util.EnumSet;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.Set;
-import java.util.concurrent.*;
-
-import static org.mockito.Mockito.*;
-
 public class RoutingTableImplTest {
 
-  private final URI namespace = URI.create("http://cisco.com/example");
-  private final QName QNAME = new QName(namespace, "global");
-
-  private IClusterGlobalServices clusterService;
-  private RoutingTableImpl<RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier>, String> routingTable;
-  ConcurrentMap mockGlobalRpcCache;
-  ConcurrentMap mockRpcCache;
-
-  @Before
-  public void setUp() throws Exception{
-    clusterService = mock(IClusterGlobalServices.class);
-    routingTable = new RoutingTableImpl<RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier>, String>();
-    mockGlobalRpcCache = new ConcurrentHashMap<>();
-    mockRpcCache = new ConcurrentHashMap<>();
-    createRoutingTableCache();
-  }
-
-  @After
-  public void tearDown(){
-    reset(clusterService);
-    mockGlobalRpcCache = null;
-    mockRpcCache = null;
-  }
+    private final URI namespace = URI.create("http://cisco.com/example");
+    private final QName QNAME = new QName(namespace, "global");
+
+    private IClusterGlobalServices clusterService;
+    private RoutingTableImpl<RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier>, String> routingTable;
+    ConcurrentMap mockGlobalRpcCache;
+    ConcurrentMap mockRpcCache;
+
+    @Before
+    public void setUp() throws Exception{
+        clusterService = mock(IClusterGlobalServices.class);
+        routingTable = new RoutingTableImpl<RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier>, String>();
+        mockGlobalRpcCache = new ConcurrentHashMap<>();
+        mockRpcCache = new ConcurrentHashMap<>();
+        createRoutingTableCache();
+    }
 
-  @Test
-  public void addGlobalRoute_ValidArguments_ShouldAdd() throws Exception {
+    @After
+    public void tearDown(){
+        reset(clusterService);
+        mockGlobalRpcCache = null;
+        mockRpcCache = null;
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+    @Test
+    public void addGlobalRoute_ValidArguments_ShouldAdd() throws Exception {
 
-    final String expectedRoute = "172.27.12.1:5000";
-    routingTable.addGlobalRoute(routeIdentifier, expectedRoute);
+        Assert.assertNotNull(mockGlobalRpcCache);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
 
-    ConcurrentMap latestCache = routingTable.getGlobalRpcCache();
-    Assert.assertEquals(mockGlobalRpcCache, latestCache);
-    Assert.assertEquals(expectedRoute, latestCache.get(routeIdentifier));
-  }
+        final String expectedRoute = "172.27.12.1:5000";
+        routingTable.addGlobalRoute(routeIdentifier, expectedRoute);
 
-  @Test (expected = RoutingTable.DuplicateRouteException.class)
-  public void addGlobalRoute_DuplicateRoute_ShouldThrow() throws Exception{
+        ConcurrentMap latestCache = routingTable.getGlobalRpcCache();
+        Assert.assertEquals(mockGlobalRpcCache, latestCache);
+        Assert.assertEquals(expectedRoute, latestCache.get(routeIdentifier));
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
+    @Test (expected = RoutingTable.DuplicateRouteException.class)
+    public void addGlobalRoute_DuplicateRoute_ShouldThrow() throws Exception{
 
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
-    routingTable.addGlobalRoute(routeIdentifier, new String());
-    routingTable.addGlobalRoute(routeIdentifier, new String());
-  }
+        Assert.assertNotNull(mockGlobalRpcCache);
 
-  @Test
-  public void getGlobalRoute_ExistingRouteId_ShouldReturnRoute() throws Exception {
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+        routingTable.addGlobalRoute(routeIdentifier, new String());
+        routingTable.addGlobalRoute(routeIdentifier, new String());
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
-    String expectedRoute = "172.27.12.1:5000";
+    @Test
+    public void getGlobalRoute_ExistingRouteId_ShouldReturnRoute() throws Exception {
 
-    routingTable.addGlobalRoute(routeIdentifier, expectedRoute);
+        Assert.assertNotNull(mockGlobalRpcCache);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+        String expectedRoute = "172.27.12.1:5000";
 
-    String actualRoute = (String) routingTable.getGlobalRoute(routeIdentifier);
-    Assert.assertEquals(expectedRoute, actualRoute);
-  }
+        routingTable.addGlobalRoute(routeIdentifier, expectedRoute);
 
-  @Test
-  public void getGlobalRoute_NonExistentRouteId_ShouldReturnNull() throws Exception {
+        String actualRoute = routingTable.getGlobalRoute(routeIdentifier);
+        Assert.assertEquals(expectedRoute, actualRoute);
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+    @Test
+    public void getGlobalRoute_NonExistentRouteId_ShouldReturnNull() throws Exception {
 
-    String actualRoute = (String) routingTable.getGlobalRoute(routeIdentifier);
-    Assert.assertNull(actualRoute);
-  }
+        Assert.assertNotNull(mockGlobalRpcCache);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
 
-  @Test
-  public void removeGlobalRoute_ExistingRouteId_ShouldRemove() throws Exception {
+        String actualRoute = routingTable.getGlobalRoute(routeIdentifier);
+        Assert.assertNull(actualRoute);
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+    @Test
+    public void removeGlobalRoute_ExistingRouteId_ShouldRemove() throws Exception {
 
-    ConcurrentMap cache = routingTable.getGlobalRpcCache();
-    Assert.assertTrue(cache.size() == 0);
-    routingTable.addGlobalRoute(routeIdentifier, "172.27.12.1:5000");
-    Assert.assertTrue(cache.size() == 1);
+        Assert.assertNotNull(mockGlobalRpcCache);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
 
-    routingTable.removeGlobalRoute(routeIdentifier);
-    Assert.assertTrue(cache.size() == 0);
+        ConcurrentMap cache = routingTable.getGlobalRpcCache();
+        Assert.assertTrue(cache.size() == 0);
+        routingTable.addGlobalRoute(routeIdentifier, "172.27.12.1:5000");
+        Assert.assertTrue(cache.size() == 1);
 
-  }
+        routingTable.removeGlobalRoute(routeIdentifier);
+        Assert.assertTrue(cache.size() == 0);
 
-  @Test
-  public void removeGlobalRoute_NonExistentRouteId_ShouldDoNothing() throws Exception {
+    }
 
-    Assert.assertNotNull(mockGlobalRpcCache);
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
+    @Test
+    public void removeGlobalRoute_NonExistentRouteId_ShouldDoNothing() throws Exception {
 
-    ConcurrentMap cache = routingTable.getGlobalRpcCache();
-    Assert.assertTrue(cache.size() == 0);
+        Assert.assertNotNull(mockGlobalRpcCache);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = getRouteIdentifier();
 
-    routingTable.removeGlobalRoute(routeIdentifier);
-    Assert.assertTrue(cache.size() == 0);
+        ConcurrentMap cache = routingTable.getGlobalRpcCache();
+        Assert.assertTrue(cache.size() == 0);
 
-  }
+        routingTable.removeGlobalRoute(routeIdentifier);
+        Assert.assertTrue(cache.size() == 0);
 
-  @Test
-  public void addRoute_ForNewRouteId_ShouldAddRoute() throws Exception {
-    Assert.assertTrue(mockRpcCache.size() == 0);
+    }
 
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeId = getRouteIdentifier();
+    @Test
+    public void addRoute_ForNewRouteId_ShouldAddRoute() throws Exception {
+        Assert.assertTrue(mockRpcCache.size() == 0);
 
-    routingTable.addRoute(routeId, new String());
-    Assert.assertTrue(mockRpcCache.size() == 1);
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeId = getRouteIdentifier();
 
-    Set<String> routes = routingTable.getRoutes(routeId);
-    Assert.assertEquals(1, routes.size());
-  }
+        routingTable.addRoute(routeId, new String());
+        Assert.assertTrue(mockRpcCache.size() == 1);
 
-  @Test
-  public void addRoute_ForExistingRouteId_ShouldAppendRoute() throws Exception {
+        Set<String> routes = routingTable.getRoutes(routeId);
+        Assert.assertEquals(1, routes.size());
+    }
 
-    Assert.assertTrue(mockRpcCache.size() == 0);
+    @Test
+    public void addRoute_ForExistingRouteId_ShouldAppendRoute() throws Exception {
 
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeId = getRouteIdentifier();
+        Assert.assertTrue(mockRpcCache.size() == 0);
 
-    String route_1 = "10.0.0.1:5955";
-    String route_2 = "10.0.0.2:5955";
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeId = getRouteIdentifier();
 
-    routingTable.addRoute(routeId, route_1);
-    routingTable.addRoute(routeId, route_2);
+        String route_1 = "10.0.0.1:5955";
+        String route_2 = "10.0.0.2:5955";
 
-    Assert.assertTrue(mockRpcCache.size() == 1);
+        routingTable.addRoute(routeId, route_1);
+        routingTable.addRoute(routeId, route_2);
 
-    Set<String> routes = routingTable.getRoutes(routeId);
-    Assert.assertEquals(2, routes.size());
-    Assert.assertTrue(routes.contains(route_1));
-    Assert.assertTrue(routes.contains(route_2));
-  }
+        Assert.assertTrue(mockRpcCache.size() == 1);
 
-  @Test
-  public void addRoute_UsingMultipleThreads_ShouldNotOverwrite(){
-    ExecutorService threadPool = Executors.newCachedThreadPool();
+        Set<String> routes = routingTable.getRoutes(routeId);
+        Assert.assertEquals(2, routes.size());
+        Assert.assertTrue(routes.contains(route_1));
+        Assert.assertTrue(routes.contains(route_2));
+    }
 
-    int numOfRoutesToAdd = 100;
-    String routePrefix_1   = "10.0.0.1:555";
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    threadPool.submit(addRoutes(numOfRoutesToAdd, routePrefix_1, routeId));
-    String routePrefix_2   = "10.0.0.1:556";
-    threadPool.submit(addRoutes(numOfRoutesToAdd, routePrefix_2, routeId));
+    @Test
+    public void addRoute_UsingMultipleThreads_ShouldNotOverwrite(){
+        ExecutorService threadPool = Executors.newCachedThreadPool();
+
+        int numOfRoutesToAdd = 100;
+        String routePrefix_1   = "10.0.0.1:555";
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        threadPool.submit(addRoutes(numOfRoutesToAdd, routePrefix_1, routeId));
+        String routePrefix_2   = "10.0.0.1:556";
+        threadPool.submit(addRoutes(numOfRoutesToAdd, routePrefix_2, routeId));
+
+        // wait for all tasks to complete; timeout in 10 sec
+        threadPool.shutdown();
+        try {
+            threadPool.awaitTermination(10, TimeUnit.SECONDS); //
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
 
-    // wait for all tasks to complete; timeout in 10 sec
-    threadPool.shutdown();
-    try {
-      threadPool.awaitTermination(10, TimeUnit.SECONDS); //
-    } catch (InterruptedException e) {
-      e.printStackTrace();
+        Assert.assertEquals(2*numOfRoutesToAdd, routingTable.getRoutes(routeId).size());
     }
 
-    Assert.assertEquals(2*numOfRoutesToAdd, routingTable.getRoutes(routeId).size());
-  }
-
-  @Test(expected = NullPointerException.class)
-  public void addRoute_NullRouteId_shouldThrowNpe() throws Exception {
+    @Test(expected = NullPointerException.class)
+    public void addRoute_NullRouteId_shouldThrowNpe() throws Exception {
 
-    routingTable.addRoute(null, new String());
-  }
+        routingTable.addRoute(null, new String());
+    }
 
-  @Test(expected = NullPointerException.class)
-  public void addRoute_NullRoute_shouldThrowNpe() throws Exception{
+    @Test(expected = NullPointerException.class)
+    public void addRoute_NullRoute_shouldThrowNpe() throws Exception{
 
-    routingTable.addRoute(getRouteIdentifier(), null);
-  }
+        routingTable.addRoute(getRouteIdentifier(), null);
+    }
 
-  @Test (expected = UnsupportedOperationException.class)
-  public void getRoutes_Call_ShouldReturnImmutableCopy() throws Exception{
-    Assert.assertNotNull(routingTable);
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    routingTable.addRoute(routeId, new String());
+    @Test (expected = UnsupportedOperationException.class)
+    public void getRoutes_Call_ShouldReturnImmutableCopy() throws Exception{
+        Assert.assertNotNull(routingTable);
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        routingTable.addRoute(routeId, new String());
 
-    Set<String> routes = routingTable.getRoutes(routeId); //returns Immutable Set
+        Set<String> routes = routingTable.getRoutes(routeId); //returns Immutable Set
 
-    routes.add(new String()); //can not be modified; should throw
-  }
+        routes.add(new String()); //can not be modified; should throw
+    }
 
-  @Test
-  public void getRoutes_With2RoutesFor1RouteId_ShouldReturnASetWithSize2() throws Exception{
-    Assert.assertNotNull(routingTable);
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    routingTable.addRoute(routeId, "10.0.0.1:5555");
-    routingTable.addRoute(routeId, "10.0.0.2:5555");
+    @Test
+    public void getRoutes_With2RoutesFor1RouteId_ShouldReturnASetWithSize2() throws Exception{
+        Assert.assertNotNull(routingTable);
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        routingTable.addRoute(routeId, "10.0.0.1:5555");
+        routingTable.addRoute(routeId, "10.0.0.2:5555");
 
-    Set<String> routes = routingTable.getRoutes(routeId); //returns Immutable Set
+        Set<String> routes = routingTable.getRoutes(routeId); //returns Immutable Set
 
-    Assert.assertEquals(2, routes.size());
-  }
+        Assert.assertEquals(2, routes.size());
+    }
 
-  @Test
-  public void getLastAddedRoute_WhenMultipleRoutesExists_ShouldReturnLatestRoute()
-    throws Exception {
+    @Test
+    public void getLastAddedRoute_WhenMultipleRoutesExists_ShouldReturnLatestRoute()
+            throws Exception {
 
-    Assert.assertNotNull(routingTable);
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    String route_1 = "10.0.0.1:5555";
-    String route_2 = "10.0.0.2:5555";
-    routingTable.addRoute(routeId, route_1);
-    routingTable.addRoute(routeId, route_2);
+        Assert.assertNotNull(routingTable);
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        String route_1 = "10.0.0.1:5555";
+        String route_2 = "10.0.0.2:5555";
+        routingTable.addRoute(routeId, route_1);
+        routingTable.addRoute(routeId, route_2);
 
-    Assert.assertEquals(route_2, routingTable.getLastAddedRoute(routeId));
-  }
+        Assert.assertEquals(route_2, routingTable.getLastAddedRoute(routeId));
+    }
 
-  @Test
-  public void removeRoute_WhenMultipleRoutesExist_RemovesGivenRoute() throws Exception{
-    Assert.assertNotNull(routingTable);
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    String route_1 = "10.0.0.1:5555";
-    String route_2 = "10.0.0.2:5555";
+    @Test
+    public void removeRoute_WhenMultipleRoutesExist_RemovesGivenRoute() throws Exception{
+        Assert.assertNotNull(routingTable);
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        String route_1 = "10.0.0.1:5555";
+        String route_2 = "10.0.0.2:5555";
 
-    routingTable.addRoute(routeId, route_1);
-    routingTable.addRoute(routeId, route_2);
+        routingTable.addRoute(routeId, route_1);
+        routingTable.addRoute(routeId, route_2);
 
-    Assert.assertEquals(2, routingTable.getRoutes(routeId).size());
+        Assert.assertEquals(2, routingTable.getRoutes(routeId).size());
 
-    routingTable.removeRoute(routeId, route_1);
-    Assert.assertEquals(1, routingTable.getRoutes(routeId).size());
+        routingTable.removeRoute(routeId, route_1);
+        Assert.assertEquals(1, routingTable.getRoutes(routeId).size());
 
-  }
+    }
 
-  @Test
-  public void removeRoute_WhenOnlyOneRouteExists_RemovesRouteId() throws Exception{
-    Assert.assertNotNull(routingTable);
-    RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
-    String route_1 = "10.0.0.1:5555";
+    @Test
+    public void removeRoute_WhenOnlyOneRouteExists_RemovesRouteId() throws Exception{
+        Assert.assertNotNull(routingTable);
+        RpcRouter.RouteIdentifier routeId = getRouteIdentifier();
+        String route_1 = "10.0.0.1:5555";
 
-    routingTable.addRoute(routeId, route_1);
-    Assert.assertEquals(1, routingTable.getRoutes(routeId).size());
+        routingTable.addRoute(routeId, route_1);
+        Assert.assertEquals(1, routingTable.getRoutes(routeId).size());
 
-    routingTable.removeRoute(routeId, route_1);
-    ConcurrentMap cache = routingTable.getRpcCache();
-    Assert.assertFalse(cache.containsKey(routeId));
+        routingTable.removeRoute(routeId, route_1);
+        ConcurrentMap cache = routingTable.getRpcCache();
+        Assert.assertFalse(cache.containsKey(routeId));
 
-  }
+    }
 
-  /*
-   * Private helper methods
-   */
-  private void createRoutingTableCache() throws Exception {
+    /*
+     * Private helper methods
+     */
+    private void createRoutingTableCache() throws Exception {
 
-    //here init
-    Component c = mock(Component.class);
+        //here init
+        Component c = mock(Component.class);
 
-    when(clusterService.existCache(
-        RoutingTableImpl.GLOBALRPC_CACHE)).thenReturn(false);
+        when(clusterService.existCache(
+                RoutingTableImpl.GLOBALRPC_CACHE)).thenReturn(false);
 
-    when(clusterService.createCache(RoutingTableImpl.GLOBALRPC_CACHE,
-        EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL))).
-        thenReturn(mockGlobalRpcCache);
+        when(clusterService.createCache(RoutingTableImpl.GLOBALRPC_CACHE,
+                EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL))).
+                thenReturn(mockGlobalRpcCache);
 
-    when(clusterService.existCache(
-        RoutingTableImpl.RPC_CACHE)).thenReturn(false);
+        when(clusterService.existCache(
+                RoutingTableImpl.RPC_CACHE)).thenReturn(false);
 
-    when(clusterService.createCache(RoutingTableImpl.RPC_CACHE,
-        EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL))).
-        thenReturn(mockRpcCache);
+        when(clusterService.createCache(RoutingTableImpl.RPC_CACHE,
+                EnumSet.of(IClusterServices.cacheMode.TRANSACTIONAL))).
+                thenReturn(mockRpcCache);
 
-    doNothing().when(clusterService).tbegin();
-    doNothing().when(clusterService).tcommit();
+        doNothing().when(clusterService).tbegin();
+        doNothing().when(clusterService).tcommit();
 
-    routingTable.setClusterGlobalServices(this.clusterService);
-    routingTable.init(c);
+        routingTable.setClusterGlobalServices(this.clusterService);
+        routingTable.init(c);
 
-    Assert.assertEquals(mockGlobalRpcCache, routingTable.getGlobalRpcCache());
-    Assert.assertEquals(mockRpcCache, routingTable.getRpcCache());
-  }
+        Assert.assertEquals(mockGlobalRpcCache, routingTable.getGlobalRpcCache());
+        Assert.assertEquals(mockRpcCache, routingTable.getRpcCache());
+    }
 
-  private RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> getRouteIdentifier(){
-    RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = mock(RpcRouter.RouteIdentifier.class);
-    InstanceIdentifier identifier = mock(InstanceIdentifier.class);
-    when(routeIdentifier.getType()).thenReturn(QNAME);
-    when(routeIdentifier.getRoute()).thenReturn(identifier);
+    private RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> getRouteIdentifier(){
+        RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier> routeIdentifier = mock(RpcRouter.RouteIdentifier.class);
+        InstanceIdentifier identifier = mock(InstanceIdentifier.class);
+        when(routeIdentifier.getType()).thenReturn(QNAME);
+        when(routeIdentifier.getRoute()).thenReturn(identifier);
 
-    return routeIdentifier;
-  }
+        return routeIdentifier;
+    }
 
-  private Runnable addRoutes(final int numRoutes, final String routePrefix, final RpcRouter.RouteIdentifier routeId){
-    return new Runnable() {
-      @Override
-      public void run() {
-        for (int i=0;i<numRoutes;i++){
-          String route = routePrefix + i;
-          try {
-            routingTable.addRoute(routeId, route);
-          } catch (Exception e) {
-            e.printStackTrace();
-          }
-        }
-      }
-    };
-  }
+    private Runnable addRoutes(final int numRoutes, final String routePrefix, final RpcRouter.RouteIdentifier routeId){
+        return new Runnable() {
+            @Override
+            public void run() {
+                for (int i=0;i<numRoutes;i++){
+                    String route = routePrefix + i;
+                    try {
+                        routingTable.addRoute(routeId, route);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        };
+    }
 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.