*/
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;
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;
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,
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());
}
}
}
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;
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>>
.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()
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;
if (vlanId != 0) {
tpAugmentationBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
- tpAugmentationBuilder.setVlanTag(new VlanId(vlanId));
+ tpAugmentationBuilder.setVlanTag(new VlanId(Uint16.valueOf(vlanId)));
}
if (itmConfig.isUseOfTunnels()) {
ovsBridgeRefEntryCache));
} else {
ItmMonitorIntervalWorker toggleWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
- dataObjectModification.getInterval().toJava(), broker);
+ dataObjectModification.getInterval(), broker);
jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
}
}
jobCoordinator.enqueueJob(tzone.getZoneName(), monitorWorker);
} else {
ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
- dataObjectModificationAfter.getInterval().toJava(), broker);
+ dataObjectModificationAfter.getInterval(), broker);
jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
}
}
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);
}
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());
});
}
}
- 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);
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;
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>() {
}
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)
@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
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());
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}.
.setDefTzTunnelType(ITMConstants.TUNNEL_TYPE_VXLAN)
.setGpeExtensionEnabled(false)
.setPortname("")
- .setVlanId(0)
+ .setVlanId(Uint16.ZERO)
.setUseOfTunnels(true)
.build();
bind(ItmConfig.class).toInstance(itmConfigObj);