Merge "Added copyright and updated appropriate log levels"

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
index 611de0973997847b11cdbb7aeed4c6da14ce329c..b0e7098c4f560503c4ec98c62c650e401cec55fb 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
@@ -358,6 +358,7 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
   private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
                         final VrfEntry vrfEntry) {
     GetEgressPointerOutput adjacency = null;
+    LOG.trace("resolveAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
     try {
       Future<RpcResult<GetEgressPointerOutput>> result =
           l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId)

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/fibmanager/impl/rev150325/FibmanagerImplModule.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/fibmanager/impl/rev150325/FibmanagerImplModule.java
index 303d60ae5805835bff6cc3151d8e48212537f780..eada290ae1a8bcf6e6b22f848b4e084ac249f7fc 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/fibmanager/impl/rev150325/FibmanagerImplModule.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/fibmanager/impl/rev150325/FibmanagerImplModule.java
@@ -25,9 +25,9 @@ public class FibmanagerImplModule extends org.opendaylight.yang.gen.v1.urn.opend
     @Override
     public java.lang.AutoCloseable createInstance() {
         FibManagerProvider provider = new FibManagerProvider();
-        getBrokerDependency().registerProvider(provider);
         provider.setMdsalManager(getMdsalutilDependency());
         provider.setVpnmanager(getVpnmanagerDependency());
+        getBrokerDependency().registerProvider(provider);
         return provider;
     }
 

diff --git a/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java b/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
index 7eb3bd3a0ad1e16b3132303a7f6c942af5dbd7a0..a57086a42cab68bf2dbe15c6c5061c7414b09ac5 100644 (file)
--- a/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
+++ b/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
@@ -72,14 +72,14 @@ public class IdManager implements IdManagerService, AutoCloseable{
         return result;
     }
 
-    private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
+    protected  <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
                                                    InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
         WriteTransaction tx = broker.newWriteOnlyTransaction();
         tx.put(datastoreType, path, data, true);
         Futures.addCallback(tx.submit(), callback);
     }
 
-    private <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
+    protected  <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
                                                     InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
         WriteTransaction tx = broker.newWriteOnlyTransaction();
         tx.merge(datastoreType, path, data, true);
@@ -95,7 +95,7 @@ public class IdManager implements IdManagerService, AutoCloseable{
         long poolSize = input.getPoolSize().longValue();
         RpcResultBuilder<Void> rpcResultBuilder;
 
-        LOG.debug("poolName: %s, startIndx: %d , poolSize: %d ", poolName, startIndx,  poolSize);
+        LOG.debug("poolName: {}, startIndx: {} , poolSize: {} ", poolName, startIndx,  poolSize);
 
         try {
             InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
@@ -146,9 +146,9 @@ public class IdManager implements IdManagerService, AutoCloseable{
                     generatedIds = new ArrayList<GeneratedIds>();
                 }
                 if (!generatedIds.isEmpty()) {
-                    for (GeneratedIds gen_id : generatedIds) {
-                        if (gen_id.getIdKey().equals(idKey)) {
-                            newIdValue = gen_id.getIdValue();
+                    for (GeneratedIds genId : generatedIds) {
+                        if (genId.getIdKey().equals(idKey)) {
+                            newIdValue = genId.getIdValue();
                             LOG.debug("Existing id {} for the key {} ", idKey, newIdValue);
                         }
 
@@ -197,7 +197,6 @@ public class IdManager implements IdManagerService, AutoCloseable{
 
             public void onFailure(Throwable error) {
                 LOG.error("Error in Datastore write operation", error);
-            };
+            }
         };
-
 }

diff --git a/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java b/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java
new file mode 100644 (file)
index 0000000..7002c7b
--- /dev/null
+++ b/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java
@@ -0,0 +1,146 @@
+package org.opendaylight.idmanager.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.idmanager.IdManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.id.pool.GeneratedIds;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.math.BigInteger;
+import java.util.*;
+import java.util.concurrent.Future;
+
+
+@RunWith(MockitoJUnitRunner.class)
+public class IdManagerTest {
+    private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
+    Map<InstanceIdentifier<?>,DataObject> written = new HashMap<>();
+    Map<InstanceIdentifier<?>,DataObject> updated = new HashMap<>();
+    @Mock DataBroker dataBroker;
+    @Mock ReadOnlyTransaction mockReadTx;
+    @Mock WriteTransaction mockWriteTx;
+    CreateIdPoolInput createPoolTest;
+    GetUniqueIdInput  getIdInputTest;
+    IdManager idManager;
+    IdPool idPoolTest;
+    InstanceIdentifier<IdPool> identifier;
+
+    @Before
+    public void setUp() throws Exception {
+
+        idManager = new IdManager(dataBroker) {
+            protected  <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
+                                                             InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
+                written.put(path, data);
+            }
+            protected  <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
+                                                              InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
+                updated.put(path, data);
+            }
+
+        };
+        setupMocks();
+    }
+
+    private void setupMocks() {
+        createPoolTest = buildCreateIdPool("vpn", 100, 100);
+        getIdInputTest = buildUniqueId("vpn", "vpn1");
+        idPoolTest = buildIdPool("vpn", 100, 100);
+        identifier = buildInstanceIdentifier("vpn");
+        when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
+        when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
+    }
+
+    @Test
+    public void testCreateIdPool()
+    {
+        doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+                LogicalDatastoreType.OPERATIONAL, identifier);
+
+        Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
+        Collection<DataObject> idPoolVal  = new ArrayList< >();
+        idPoolVal = written.values();
+        assertEquals(1,written.size());
+            for (DataObject poolData: idPoolVal) {
+                IdPool pool = null;
+                if (poolData instanceof IdPool) {
+                    pool = (IdPool) poolData;
+                    assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
+                    assertEquals(createPoolTest.getIdStart(), pool.getIdStart());
+                    assertEquals(createPoolTest.getPoolSize(), pool.getPoolSize());
+                }
+            }
+    }
+
+    @Test
+    public void testUniqueId()
+    {
+        Optional<IdPool> expected = Optional.of(idPoolTest);
+        doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+                LogicalDatastoreType.OPERATIONAL, identifier);
+
+        idManager.getUniqueId(getIdInputTest);
+        Collection<DataObject> idPoolVal  = new ArrayList< >();
+        idPoolVal = updated.values();
+        assertEquals(1,updated.size());
+            for (DataObject poolData: idPoolVal) {
+                IdPool pool = null;
+                if (poolData instanceof IdPool) {
+                    pool = (IdPool) poolData;
+                    assertEquals(getIdInputTest.getPoolName(), pool.getPoolName());
+                    List <GeneratedIds> genIds = pool.getGeneratedIds();
+                    assertEquals(1,genIds.size());
+                }
+            }
+    }
+
+    private CreateIdPoolInput buildCreateIdPool(String poolName, long idStart, long poolSize) {
+        CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
+                .setIdStart(idStart)
+                .setPoolSize(BigInteger.valueOf(poolSize))
+                .build();
+        return createPool;
+    }
+
+    private IdPool buildIdPool(String poolName, long idStart, long poolSize) {
+        IdPool idPool = new IdPoolBuilder().setPoolName(poolName)
+                .setIdStart(idStart)
+                .setPoolSize(BigInteger.valueOf(poolSize))
+                .build();
+        return idPool;
+    }
+
+    private GetUniqueIdInput buildUniqueId(String poolName, String idKey) {
+        GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder().setPoolName(poolName)
+                .setIdKey(idKey).build();
+        return getIdInput;
+    }
+
+    private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName){
+        InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
+                InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey(poolName));
+        InstanceIdentifier<IdPool> id = idBuilder.build();
+        return id;
+    }
+}
+

diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java
index 385e5cfcb3f196b0e01d3fa170db768f78d7cb67..7737e0104d80596ff32c7c92bad34fb83db54095 100644 (file)
--- a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java
+++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/InterfaceManager.java
@@ -282,6 +282,7 @@ public class InterfaceManager extends AbstractDataChangeListener<Interface> impl
                     Node node = getNodeFromDataStore(delInterface);
                     if((node != null) &&(node.getNodeConnector().isEmpty())) {
                         dbDpnEndpoints.remove(node.getId());
+                        LOG.trace("dbDpnEndpoints: {}",dbDpnEndpoints);
                     }
                 }
             }
@@ -390,7 +391,6 @@ public class InterfaceManager extends AbstractDataChangeListener<Interface> impl
 
     void processPortUpdate(NodeConnector oldPort, NodeConnector update) {
         //TODO: Currently nothing to do here.
-        LOG.trace("ifMap: {}, dpnMap: {}", mapNcToInterfaceName, dbDpnEndpoints);
     }
 
     void processPortDelete(NodeConnector port) {

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
index 380d974e011601ca6403f62c2588662682b983f6..3221a474f4f50612d263fe4537ef4f6ef3164f85 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
@@ -143,7 +143,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
     @Override
     protected void add(final InstanceIdentifier<VpnInterface> identifier,
             final VpnInterface vpnInterface) {
-        LOG.info("key: {} , value: {}", identifier, vpnInterface );
+        LOG.trace("key: {} , value: {}", identifier, vpnInterface );
         addInterface(identifier, vpnInterface);
     }
 
@@ -179,7 +179,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
             String nextHopIp = interfaceManager.getEndpointIpForDpn(dpnId);
 
             if (!nextHops.isEmpty()) {
-                LOG.info("NextHops are {}", nextHops);
+                LOG.trace("NextHops are {}", nextHops);
                 for (Adjacency nextHop : nextHops) {
                     String key = nextHop.getIpAddress();
                     long label = getUniqueId(key);
@@ -276,7 +276,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
     }
 
     private void bindServiceOnInterface(Interface intf, long vpnId) {
-        LOG.info("Bind service on interface {} for VPN: {}", intf, vpnId);
+        LOG.trace("Bind service on interface {} for VPN: {}", intf, vpnId);
 
         long dpId = interfaceManager.getDpnForInterface(intf.getName()); 
         if(dpId == 0L) {
@@ -345,7 +345,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
 
     @Override
     protected void remove( InstanceIdentifier<VpnInterface> identifier, VpnInterface vpnInterface) {
-        LOG.info("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
+        LOG.trace("Remove event - key: {}, value: {}" ,identifier, vpnInterface );
         final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class);
         String interfaceName = key.getName();
         InstanceIdentifierBuilder<Interface> idBuilder = 
@@ -357,7 +357,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
             removeNextHops(identifier, vpnInterface);
             unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
         } else {
-            LOG.info("No nexthops were available to handle remove event {}", interfaceName);
+            LOG.warn("No nexthops were available to handle remove event {}", interfaceName);
         }
     }
 
@@ -388,7 +388,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
     }
 
     private void unbindServiceOnInterface(Interface intf, long vpnId) {
-        LOG.info("Unbind service on interface {} for VPN: {}", intf, vpnId);
+        LOG.trace("Unbind service on interface {} for VPN: {}", intf, vpnId);
 
         long dpId = interfaceManager.getDpnForInterface(intf.getName());
         if(dpId == 0L) {

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
index ee0c56eaefaccb00bb449e3136dc43ef4f57f3e6..3689cbbe21395c9f5b07089a026d0d716888482a 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
@@ -97,7 +97,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
 
     @Override
     protected void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
-        LOG.info("Remove event - Key: {}, value: {}", identifier, del);
+        LOG.trace("Remove event - Key: {}, value: {}", identifier, del);
         String vpnName = del.getVpnInstanceName();
         InstanceIdentifier<VpnInstance> vpnIdentifier = VpnUtil.getVpnInstanceIdentifier(vpnName);
         delete(LogicalDatastoreType.OPERATIONAL, vpnIdentifier);
@@ -113,13 +113,13 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
     @Override
     protected void update(InstanceIdentifier<VpnInstance> identifier,
             VpnInstance original, VpnInstance update) {
-        LOG.info("Update event - Key: {}, value: {}", identifier, update);
+        LOG.trace("Update event - Key: {}, value: {}", identifier, update);
     }
 
     @Override
     protected void add(InstanceIdentifier<VpnInstance> identifier,
             VpnInstance value) {
-        LOG.info("key: {}, value: {}" +identifier, value);
+        LOG.trace("key: {}, value: {}", identifier, value);
 
         long vpnId = getUniqueId(value.getVpnInstanceName());
 
@@ -240,7 +240,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         @Override
         protected void remove(InstanceIdentifier<VrfEntry> identifier,
                 VrfEntry del) {
-            LOG.info("Remove Fib event - Key : {}, value : {} ",identifier, del);
+            LOG.trace("Remove Fib event - Key : {}, value : {} ", identifier, del);
             final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
             String rd = key.getRouteDistinguisher();
             Long label = del.getLabel();
@@ -256,12 +256,12 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
                         LOG.debug("Fib Route entry is empty.");
                         return;
                     }
-                    LOG.info("Removing label from vpn info - {}", label);
+                    LOG.debug("Removing label from vpn info - {}", label);
                     routeIds.remove(label);
                     asyncWrite(LogicalDatastoreType.OPERATIONAL, augId,
                             new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
                 } else {
-                    LOG.info("VPN Augmentation not found");
+                    LOG.warn("VPN Augmentation not found for vpn instance {}", vpn.getVpnInstanceName());
                 }
             } else {
                 LOG.warn("No VPN Instance found for RD: {}", rd);
@@ -278,7 +278,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         @Override
         protected void add(InstanceIdentifier<VrfEntry> identifier,
                 VrfEntry add) {
-            LOG.info("Add Vrf Entry event - Key : {}, value : {}",identifier, add);
+            LOG.trace("Add Vrf Entry event - Key : {}, value : {}", identifier, add);
             final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
             String rd = key.getRouteDistinguisher();
             Long label = add.getLabel();
@@ -293,12 +293,12 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
                     if(routeIds == null) {
                         routeIds = new ArrayList<>();
                     }
-                    LOG.info("Adding label to vpn info - {}", label);
+                    LOG.debug("Adding label to vpn info - {}", label);
                     routeIds.add(label);
                     asyncWrite(LogicalDatastoreType.OPERATIONAL, augId,
                             new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
                 } else {
-                    LOG.info("VPN Augmentation not found");
+                    LOG.warn("VPN Augmentation not found for vpn instance {}", vpn.getVpnInstanceName());
                 }
             } else {
                 LOG.warn("No VPN Instance found for RD: {}", rd);

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
index 6b462e4e5d975e10698194576f9b470ecc9ea0c2..28c387d3e0e194ef0db09eb8f13484ed1078ded2 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
@@ -81,7 +81,7 @@ public class VpnserviceProvider implements BindingAwareProvider, IVpnManager,
         try {
            Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
            if ((result != null) && (result.get().isSuccessful())) {
-                LOG.info("Created IdPool for VPN Service");
+                LOG.debug("Created IdPool for VPN Service");
             }
         } catch (InterruptedException | ExecutionException e) {
             LOG.error("Failed to create idPool for VPN Service",e);