Use uint types in itm-impl

Fix most warnings coming from use of widened types by adopting
uint types.

Change-Id: Ib6d0bc78798c5605f136827c19d60ca40d728f34
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmMonitorIntervalWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmMonitorIntervalWorker.java
index 39c535a4df9bfd13847f21bfe747e77666f4d731..418d920ef72529db16ad37b451d3decf35fe75ae 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmMonitorIntervalWorker.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmMonitorIntervalWorker.java
@@ -7,6 +7,8 @@
  */
 package org.opendaylight.genius.itm.confighelpers;
 
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
 import java.util.List;
@@ -21,6 +23,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -29,28 +32,28 @@ public class ItmMonitorIntervalWorker implements Callable<List<? extends Listena
 
     private final DataBroker dataBroker;
     private final String tzone;
-    private final Integer interval;
+    private final Uint16 interval;
     private final ManagedNewTransactionRunner txRunner;
 
-    public ItmMonitorIntervalWorker(String tzone, Integer interval, DataBroker dataBroker) {
+    public ItmMonitorIntervalWorker(String tzone, Uint16 interval, DataBroker dataBroker) {
         this.dataBroker = dataBroker;
         this.tzone = tzone;
-        this.interval = interval;
+        this.interval = requireNonNull(interval);
         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
-        LOG.debug("ItmMonitorIntervalWorker: monitorInterval = {}",interval);
-        LOG.trace("ItmMonitorToggleWorker initialized with  tzone {} and Interval {}",tzone,interval);
+        LOG.debug("ItmMonitorIntervalWorker: monitorInterval = {}", interval);
+        LOG.trace("ItmMonitorToggleWorker initialized with  tzone {} and Interval {}", tzone, interval);
     }
 
     @Override
     public List<? extends ListenableFuture<?>> call() {
-        LOG.debug("Invoking Tunnel Monitor Worker tzone = {} Interval= {}",tzone,interval);
+        LOG.debug("Invoking Tunnel Monitor Worker tzone = {} Interval= {}", tzone, interval);
         return toggleTunnelMonitoring();
     }
 
     private List<? extends ListenableFuture<?>> toggleTunnelMonitoring() {
         List<ListenableFuture<?>> futures = new ArrayList<>();
         List<String> tunnelList = ItmUtils.getInternalTunnelInterfaces(dataBroker);
-        LOG.debug("ItmMonitorIntervalWorker toggleTunnelMonitoring: List of tunnel interfaces: {}" , tunnelList);
+        LOG.debug("ItmMonitorIntervalWorker toggleTunnelMonitoring: List of tunnel interfaces: {}", tunnelList);
         InstanceIdentifier<TunnelMonitorInterval> iid = InstanceIdentifier.create(TunnelMonitorInterval.class);
         TunnelMonitorInterval monitorInterval = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
         futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL,
@@ -64,7 +67,7 @@ public class ItmMonitorIntervalWorker implements Callable<List<? extends Listena
         if (tunnelInterfaceName != null) {
             LOG.debug("tunnel {} will have monitor interval {}", tunnelInterfaceName, interval);
             tx.merge(ItmUtils.buildTunnelId(tunnelInterfaceName),
-                new IfTunnelBuilder().setMonitorInterval(interval.longValue()).build());
+                new IfTunnelBuilder().setMonitorInterval(interval.toUint32()).build());
         }
     }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
index 72ec343259ea30bf4ca81ead39e703d140b752f3..4ce9821bf552a003b07abd81032aedf9e644152e 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
@@ -134,6 +134,7 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.common.Uint64;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -144,7 +145,7 @@ public final class ItmUtils {
     private static final String ITM_LLDP_FLOW_ENTRY = "ITM Flow Entry ::" + ITMConstants.LLDP_SERVICE_ID;
     private static final String TUNNEL = "tun";
     private static final IpPrefix DUMMY_IP_PREFIX = IpPrefixBuilder.getDefaultInstance(ITMConstants.DUMMY_PREFIX);
-    private static final long DEFAULT_MONITORING_INTERVAL = 100L;
+    private static final Uint32 DEFAULT_MONITORING_INTERVAL = Uint32.valueOf(100);
     public static final ItmCache ITM_CACHE = new ItmCache();
 
     public static final ImmutableMap<String, Class<? extends TunnelTypeBase>>
@@ -325,12 +326,12 @@ public final class ItmUtils {
                 .setDatapathNodeIdentifier(dpn)
                 .setParentInterface(parentIfaceName)
                 .build());
-        Long monitoringInterval = null;
+        Uint32 monitoringInterval = null;
         LOG.debug("buildTunnelInterface: monitorProtocol = {} and monitorInterval = {}",
                 monitorProtocol.getName(), monitorInterval);
 
         if (monitorInterval != null) {
-            monitoringInterval = monitorInterval.longValue();
+            monitoringInterval = Uint32.valueOf(monitorInterval);
         }
 
         return builder.addAugmentation(new IfTunnelBuilder()

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/renderer/ovs/utilities/DirectTunnelUtils.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/renderer/ovs/utilities/DirectTunnelUtils.java
index de0ca44ed36d31d16df3e1c420f8d6efd681b1f3..4e5375d8606062df3733708fd9d1ccaf67689f0d 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/renderer/ovs/utilities/DirectTunnelUtils.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/renderer/ovs/utilities/DirectTunnelUtils.java
@@ -127,6 +127,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.OperationFailedException;
 import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint16;
 import org.opendaylight.yangtools.yang.common.Uint64;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -525,7 +526,7 @@ public final class DirectTunnelUtils {
 
         if (vlanId != 0) {
             tpAugmentationBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
-            tpAugmentationBuilder.setVlanTag(new VlanId(vlanId));
+            tpAugmentationBuilder.setVlanTag(new VlanId(Uint16.valueOf(vlanId)));
         }
 
         if (itmConfig.isUseOfTunnels()) {

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
index 8ba821d7827cba5f02c9a185537ba9e185f5ea5d..d6e9ff59d41f334518fbff8328d45d561ed9d3f4 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
@@ -78,7 +78,7 @@ public class TunnelMonitorIntervalListener extends AbstractSyncDataTreeChangeLis
                         ovsBridgeRefEntryCache));
                 } else {
                     ItmMonitorIntervalWorker toggleWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModification.getInterval().toJava(), broker);
+                        dataObjectModification.getInterval(), broker);
                     jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
                 }
             }
@@ -104,7 +104,7 @@ public class TunnelMonitorIntervalListener extends AbstractSyncDataTreeChangeLis
                     jobCoordinator.enqueueJob(tzone.getZoneName(), monitorWorker);
                 } else {
                     ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModificationAfter.getInterval().toJava(), broker);
+                        dataObjectModificationAfter.getInterval(), broker);
                     jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
                 }
             }
@@ -129,7 +129,7 @@ public class TunnelMonitorIntervalListener extends AbstractSyncDataTreeChangeLis
                     jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
                 } else {
                     ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModification.getInterval().toJava(), broker);
+                        dataObjectModification.getInterval(), broker);
                     //conversion to milliseconds done while writing to i/f-mgr config DS
                     jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
                 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
index 6c5ff616991f0dce1c512664bffc30744a0fe137..306bc9574c71c3284d056357eb21dcf03c0245ef 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
@@ -194,12 +194,12 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
                         StateTunnelListKey tlKey = new StateTunnelListKey(interfaceName);
                         LOG.trace("TunnelStateKey: {} for interface: {}", tlKey, interfaceName);
                         InstanceIdentifier<StateTunnelList> stListId = ItmUtils.buildStateTunnelListId(tlKey);
-                        eventCallbacks.onRemove(LogicalDatastoreType.OPERATIONAL, stListId, (unused) -> {
+                        eventCallbacks.onRemove(LogicalDatastoreType.OPERATIONAL, stListId, unused -> {
                             LOG.trace("callback event for a delete {} interface instance....", stListId);
                             // recreating the transportZone
                             recreateTEP(tzName, tepsToRecover, eventCallbackCount, interfaceListToRecover.size());
                             return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
-                        }, Duration.ofMillis(5000), (id) -> {
+                        }, Duration.ofMillis(5000), id -> {
                                 LOG.trace("event callback timed out for {} tunnel interface ", interfaceName);
                                 recreateTEP(tzName, tepsToRecover, eventCallbackCount, interfaceListToRecover.size());
                             });
@@ -211,7 +211,8 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
         }
     }
 
-    private void recreateTEP(String tzName, List tepts, AtomicInteger eventCallbackCount, int registeredEventSize) {
+    private void recreateTEP(String tzName, List<DPNTEPsInfo> tepts, AtomicInteger eventCallbackCount,
+            int registeredEventSize) {
         eventCallbackCount.incrementAndGet();
         if (eventCallbackCount.intValue() == registeredEventSize || registeredEventSize == 0) {
             LOG.info("Re-creating TEP {}", tzName);

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java
index d2f901ccd17e86bbc503febdf000aee77b632d51..cbee6578bd1d33d1b92f388a00371d2de46e9e26 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java
@@ -172,6 +172,7 @@ import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.common.Uint64;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -401,8 +402,8 @@ public class ItmManagerRpcService implements ItmRpcService {
         LOG.debug("setBfdParamOnTunnel srcDpnId: {}, destDpnId: {}", srcDpnId, destDpnId);
         final SettableFuture<RpcResult<SetBfdParamOnTunnelOutput>> result = SettableFuture.create();
         FluentFuture<?> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
-            enableBFD(tx, srcDpnId, destDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval().toJava());
-            enableBFD(tx, destDpnId, srcDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval().toJava());
+            enableBFD(tx, srcDpnId, destDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval());
+            enableBFD(tx, destDpnId, srcDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval());
         });
 
         future.addCallback(new FutureCallback<Object>() {
@@ -423,7 +424,7 @@ public class ItmManagerRpcService implements ItmRpcService {
     }
 
     private void enableBFD(TypedWriteTransaction<Datastore.Configuration> tx, Uint64 srcDpnId, Uint64 destDpnId,
-                           final Boolean enabled, final Integer interval) throws ReadFailedException {
+                           final Boolean enabled, final Uint16 interval) throws ReadFailedException {
         DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepStateCache.getDpnTepInterface(srcDpnId, destDpnId);
         RemoteDpnsBuilder remoteDpnsBuilder = new RemoteDpnsBuilder();
         remoteDpnsBuilder.withKey(new RemoteDpnsKey(destDpnId)).setDestinationDpnId(destDpnId)
@@ -1109,21 +1110,18 @@ public class ItmManagerRpcService implements ItmRpcService {
     @Override
     public ListenableFuture<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
             IsTunnelInternalOrExternalInput input) {
-        RpcResultBuilder<IsTunnelInternalOrExternalOutput> resultBld;
         String tunIfName = input.getTunnelInterfaceName();
-        long tunVal = 0;
-        IsTunnelInternalOrExternalOutputBuilder output = new IsTunnelInternalOrExternalOutputBuilder()
-                .setTunnelType(tunVal);
-
+        final Uint32 tunVal;
         if (ItmUtils.ITM_CACHE.getInternalTunnel(tunIfName) != null) {
-            tunVal = 1;
+            tunVal = Uint32.ONE;
         } else if (ItmUtils.ITM_CACHE.getExternalTunnel(tunIfName) != null) {
-            tunVal = 2;
+            tunVal = Uint32.TWO;
+        } else {
+            tunVal = Uint32.ZERO;
         }
-        output.setTunnelType(tunVal);
-        resultBld = RpcResultBuilder.success();
-        resultBld.withResult(output.build());
-        return Futures.immediateFuture(resultBld.build());
+
+        return RpcResultBuilder.success(new IsTunnelInternalOrExternalOutputBuilder().setTunnelType(tunVal).build())
+                .buildFuture();
     }
 
     @Override
@@ -1135,18 +1133,15 @@ public class ItmManagerRpcService implements ItmRpcService {
             tx -> dcGatewayIpList.putAll(getDcGatewayIpList(tx))).isDone();
         String dcgwIpStr = input.getDcgwIp();
         IpAddress dcgwIpAddr = IpAddressBuilder.getDefaultInstance(dcgwIpStr);
-        long retVal;
 
         if (!dcGatewayIpList.isEmpty()
                 && dcGatewayIpList.values().stream().anyMatch(gwIp -> dcgwIpAddr.equals(gwIp.getIpAddress()))) {
             //Match found
-            retVal = 1;
-            IsDcgwPresentOutputBuilder output = new IsDcgwPresentOutputBuilder().setRetVal(retVal);
+            IsDcgwPresentOutputBuilder output = new IsDcgwPresentOutputBuilder().setRetVal(Uint32.ONE);
             resultBld.withResult(output.build());
         } else {
             //Match not found
-            retVal = 2;
-            IsDcgwPresentOutputBuilder output = new IsDcgwPresentOutputBuilder().setRetVal(retVal);
+            IsDcgwPresentOutputBuilder output = new IsDcgwPresentOutputBuilder().setRetVal(Uint32.TWO);
             resultBld.withResult(output.build());
         }
         return Futures.immediateFuture(resultBld.build());

diff --git a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java
index 377f11c9f31d89b20e1743e5408a8c41096ea390..a9a8d3bc980050d10be5c446a8638735be83a7f7 100644 (file)
--- a/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java
+++ b/itm/itm-impl/src/test/java/org/opendaylight/genius/itm/tests/ItmTestModule.java
@@ -55,6 +55,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfigBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
+import org.opendaylight.yangtools.yang.common.Uint16;
 
 /**
  * Dependency Injection Wiring for {@link ItmTest}.
@@ -74,7 +75,7 @@ public class ItmTestModule extends AbstractGuiceJsr250Module {
                 .setDefTzTunnelType(ITMConstants.TUNNEL_TYPE_VXLAN)
                 .setGpeExtensionEnabled(false)
                 .setPortname("")
-                .setVlanId(0)
+                .setVlanId(Uint16.ZERO)
                 .setUseOfTunnels(true)
                 .build();
         bind(ItmConfig.class).toInstance(itmConfigObj);