import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
@SuppressFBWarnings("NP_NONNULL_RETURN_VIOLATION")
public String handlePacketIn(ARP packet, PacketReceived packetReceived) {
- short tableId = packetReceived.getTableId().getValue();
+ short tableId = packetReceived.getTableId().getValue().toJava();
int arpType = packet.getOpCode();
if (LOG.isTraceEnabled()) {
LOG.trace("packet: {}", packetReceived);
}
- BigInteger metadata = packetReceived.getMatch().getMetadata().getMetadata();
+ Uint64 metadata = packetReceived.getMatch().getMetadata().getMetadata();
int portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
String interfaceName = null;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.alivenessmonitor.protocols.internal;
import static org.opendaylight.genius.alivenessmonitor.protocols.AlivenessMonitorAndProtocolsConstants.SEPERATOR;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.interfaces.InterfaceAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.warn("Failed to decode IPv6 NA packet={}", data, e);
return null;
}
- short tableId = packetReceived.getTableId().getValue();
+ short tableId = packetReceived.getTableId().getValue().toJava();
LOG.trace("packet: {}, tableId {}, ipv6Type {}", packetReceived, tableId, naPacket.getIcmp6Type());
- BigInteger metadata = packetReceived.getMatch().getMetadata().getMetadata();
+ Uint64 metadata = packetReceived.getMatch().getMetadata().getMetadata();
int portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
String interfaceName = null;
return null;
}
- @SuppressWarnings("deprecation")
@Override
public void startMonitoringTask(MonitoringInfo monitorInfo) {
EndpointType source = monitorInfo.getSource().getEndpointType();
import com.google.common.base.Optional;
import com.google.common.base.Strings;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
TransmitPacketInput transmitPacketInput = MDSALUtil.getPacketOut(actions, ethenetLLDPPacket.serialize(),
- nodeId, MDSALUtil.getNodeConnRef(BigInteger.valueOf(nodeId), "0xfffffffd"));
+ nodeId, MDSALUtil.getNodeConnRef(Uint64.valueOf(nodeId), "0xfffffffd"));
addErrorLogging(packetProcessingService.transmitPacket(transmitPacketInput),
LOG, "transmitPacket() failed: {}", transmitPacketInput);
} catch (InterruptedException | ExecutionException | PacketException e) {
List<ActionInfo> actionInfos = new ArrayList<>();
// Set the LLDP service Id which is 0
if (Tunnel.class.equals(intfType)) {
- actionInfos.add(new ActionSetFieldTunnelId(BigInteger.ZERO));
+ actionInfos.add(new ActionSetFieldTunnelId(Uint64.ZERO));
}
actionInfos.add(new ActionOutput(new Uri(Long.toString(portNum))));
return actionInfos;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class AlivenessMonitorTest {
doReturn(CommitInfo.emptyFluentFuture()).when(readWriteTx).commit();
RpcResult<MonitorProfileCreateOutput> output = alivenessMonitor
.monitorProfileCreate(input).get();
- return output.getResult().getProfileId();
+ return output.getResult().getProfileId().toJava();
}
private MonitorProfile getTestMonitorProfile() {
private InterfaceMonitorEntry getInterfaceMonitorEntry() {
return new InterfaceMonitorEntryBuilder()
.setInterfaceName("test-interface")
- .setMonitorIds(Arrays.asList(1L, 2L)).build();
+ .setMonitorIds(Arrays.asList(Uint32.valueOf(1L), Uint32.valueOf(2L))).build();
}
private Interface getInterface(String ipAddress) {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final IdManagerService idManager;
private final NotificationPublishService notificationPublishService;
private final AlivenessProtocolHandlerRegistry alivenessProtocolHandlerRegistry;
- private final ConcurrentMap<Long, ScheduledFuture<?>> monitoringTasks = new ConcurrentHashMap<>();
+ private final ConcurrentMap<Uint32, ScheduledFuture<?>> monitoringTasks = new ConcurrentHashMap<>();
private final ScheduledExecutorService monitorService;
private final ExecutorService callbackExecutorService;
- private final LoadingCache<Long, String> monitorIdKeyCache;
+ private final LoadingCache<Uint32, String> monitorIdKeyCache;
private final ConcurrentMap<String, Semaphore> lockMap = new ConcurrentHashMap<>();
@Inject
callbackExecutorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE, "Aliveness Callback Handler", LOG);
createIdPool();
- monitorIdKeyCache = CacheBuilder.newBuilder().build(new CacheLoader<Long, String>() {
+ monitorIdKeyCache = CacheBuilder.newBuilder().build(new CacheLoader<Uint32, String>() {
@Override
- public String load(@NonNull Long monitorId) {
+ public String load(Uint32 monitorId) {
try {
return txRunner.<Operational, ExecutionException, Optional<MonitoridKeyEntry>>
applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
- tx -> tx.read(getMonitorMapId(monitorId)).get()).map(MonitoridKeyEntry::getMonitorKey)
+ tx -> tx.read(getMonitorMapId(monitorId)).get())
+ .map(MonitoridKeyEntry::getMonitorKey)
.orElse(null);
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error reading monitor {}", monitorId, e);
public ListenableFuture<RpcResult<MonitorStartOutput>> monitorStart(MonitorStartInput input) {
RpcResultBuilder<MonitorStartOutput> rpcResultBuilder;
final Config in = input.getConfig();
- Long profileId = in.getProfileId();
+ Uint32 profileId = in.getProfileId();
LOG.debug("Monitor Start invoked with Config: {}, Profile Id: {}", in, profileId);
try {
tx -> tx.read(getMonitorProfileId(profileId)).get());
final MonitorProfile profile;
if (!optProfile.isPresent()) {
- String errMsg = String.format("No monitoring profile associated with Id: %d", profileId);
+ String errMsg = "No monitoring profile associated with Id: " + profileId;
LOG.error("Monitor start failed. {}", errMsg);
throw new RuntimeException(errMsg);
} else {
destEndpointType = in.getDestination().getEndpointType();
}
String idKey = getUniqueKey(interfaceName, protocolType.toString(), srcEndpointType, destEndpointType);
- final long monitorId = getUniqueId(idKey);
+ final Uint32 monitorId = Uint32.valueOf(getUniqueId(idKey));
Optional<MonitoringInfo> optKey =
txRunner.<Operational, ExecutionException, Optional<MonitoringInfo>>
applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
return Futures.immediateFuture(rpcResultBuilder.build());
}
- private void associateMonitorIdWithInterface(final Long monitorId, final String interfaceName) {
+ private void associateMonitorIdWithInterface(final Uint32 monitorId, final String interfaceName) {
LOG.debug("associate monitor Id {} with interface {}", monitorId, interfaceName);
final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
FluentFuture<Optional<InterfaceMonitorEntry>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL,
FluentFuture<? extends CommitInfo> updateFuture = readFuture.transformAsync(optEntry -> {
if (optEntry.isPresent()) {
InterfaceMonitorEntry entry = optEntry.get();
- List<Long> monitorIds1 =
+ List<Uint32> monitorIds1 =
entry.getMonitorIds() != null ? new ArrayList<>(entry.getMonitorIds()) : new ArrayList<>();
monitorIds1.add(monitorId);
InterfaceMonitorEntry newEntry1 = new InterfaceMonitorEntryBuilder()
// Create new monitor entry
LOG.debug("Adding new interface-monitor association for interface {} with id {}", interfaceName,
monitorId);
- List<Long> monitorIds2 = new ArrayList<>();
+ List<Uint32> monitorIds2 = new ArrayList<>();
monitorIds2.add(monitorId);
InterfaceMonitorEntry newEntry2 = new InterfaceMonitorEntryBuilder()
.setInterfaceName(interfaceName).setMonitorIds(monitorIds2).build();
}, callbackExecutorService);
Futures.addCallback(updateFuture, new FutureCallbackImpl(
- String.format("Association of monitorId %d with Interface %s", monitorId, interfaceName)),
+ "Association of monitorId " + monitorId + " with Interface " + interfaceName),
MoreExecutors.directExecutor());
}
- private void scheduleMonitoringTask(MonitoringInfo monitoringInfo, long monitorInterval) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private void scheduleMonitoringTask(MonitoringInfo monitoringInfo, Uint32 monitorInterval) {
AlivenessMonitorTask monitorTask = new AlivenessMonitorTask(monitoringInfo);
ScheduledFuture<?> scheduledFutureResult = monitorService.scheduleAtFixedRate(monitorTask, NO_DELAY,
- monitorInterval, TimeUnit.MILLISECONDS);
+ monitorInterval.toJava(), TimeUnit.MILLISECONDS);
monitoringTasks.put(monitoringInfo.getId(), scheduledFutureResult);
}
public ListenableFuture<RpcResult<MonitorPauseOutput>> monitorPause(MonitorPauseInput input) {
LOG.debug("Monitor Pause operation invoked for monitor id: {}", input.getMonitorId());
SettableFuture<RpcResult<MonitorPauseOutput>> result = SettableFuture.create();
- final Long monitorId = input.getMonitorId();
+ final Uint32 monitorId = input.getMonitorId();
// Set the monitoring status to Paused
updateMonitorStatusTo(monitorId, MonitorStatus.Paused, currentStatus -> currentStatus == MonitorStatus.Started);
if (stopMonitoringTask(monitorId)) {
result.set(RpcResultBuilder.<MonitorPauseOutput>success().build());
} else {
- String errorMsg = String.format("No Monitoring Task availble to pause for the given monitor id : %d",
- monitorId);
+ String errorMsg = "No Monitoring Task availble to pause for the given monitor id : " + monitorId;
LOG.error("Monitor Pause operation failed- {}", errorMsg);
result.set(RpcResultBuilder.<MonitorPauseOutput>failed()
.withError(ErrorType.APPLICATION, errorMsg).build());
LOG.debug("Monitor Unpause operation invoked for monitor id: {}", input.getMonitorId());
final SettableFuture<RpcResult<MonitorUnpauseOutput>> result = SettableFuture.create();
- final Long monitorId = input.getMonitorId();
+ final Uint32 monitorId = input.getMonitorId();
final ReadTransaction tx = dataBroker.newReadOnlyTransaction();
FluentFuture<Optional<MonitoringInfo>> readInfoResult = tx.read(LogicalDatastoreType.OPERATIONAL,
getMonitoringInfoId(monitorId));
@Override
public void onFailure(Throwable error) {
tx.close();
- String msg = String.format("Unable to read monitoring info associated with monitor id %d", monitorId);
+ String msg = "Unable to read monitoring info associated with monitor id " + monitorId;
LOG.error("Monitor unpause Failed. {}", msg, error);
result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
.withError(ErrorType.APPLICATION, msg, error).build());
@Override
public void onFailure(Throwable error) {
tx.close();
- String msg = String.format("Unable to read Monitoring profile associated with id %d",
- info.getProfileId());
+ String msg = "Unable to read Monitoring profile associated with id " + info.getProfileId();
LOG.warn("Monitor unpause Failed. {}", msg, error);
result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
.withError(ErrorType.APPLICATION, msg, error).build());
}
result.set(RpcResultBuilder.<MonitorUnpauseOutput>success().build());
} else {
- String msg = String.format("Monitoring profile associated with id %d is not present",
+ String msg = String.format("Monitoring profile associated with id %s is not present",
info.getProfileId());
LOG.warn("Monitor unpause Failed. {}", msg);
result.set(
}, callbackExecutorService);
} else {
tx.close();
- String msg = String.format("Monitoring info associated with id %d is not present", monitorId);
+ String msg = String.format("Monitoring info associated with id %s is not present", monitorId);
LOG.warn("Monitor unpause Failed. {}", msg);
result.set(RpcResultBuilder.<MonitorUnpauseOutput>failed()
.withError(ErrorType.APPLICATION, msg).build());
return result;
}
- private boolean stopMonitoringTask(Long monitorId) {
+ private boolean stopMonitoringTask(Uint32 monitorId) {
return stopMonitoringTask(monitorId, INTERRUPT_TASK);
}
- private boolean stopMonitoringTask(Long monitorId, boolean interruptTask) {
+ private boolean stopMonitoringTask(Uint32 monitorId, boolean interruptTask) {
Optional<MonitoringInfo> optInfo;
try {
optInfo = txRunner.applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
return false;
}
- Optional<MonitorProfile> getMonitorProfile(Long profileId) {
+ Optional<MonitorProfile> getMonitorProfile(Uint32 profileId) {
try {
return txRunner.applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
tx -> tx.read(getMonitorProfileId(profileId))).get();
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void sendMonitorPacket(final MonitoringInfo monitoringInfo) {
// TODO: Handle interrupts
- final Long monitorId = monitoringInfo.getId();
+ final Uint32 monitorId = monitoringInfo.getId();
final String monitorKey = monitorIdKeyCache.getUnchecked(monitorId);
if (monitorKey == null) {
LOG.warn("No monitor Key associated with id {} to send the monitor packet", monitorId);
MonitoringState state = optState.get();
// Increase the request count
- Long requestCount = state.getRequestCount() + 1;
+ Long requestCount = state.getRequestCount().toJava() + 1;
// Check with the monitor window
LivenessState currentLivenessState = state.getState();
// Increase the pending response count
- long responsePendingCount = state.getResponsePendingCount();
- if (responsePendingCount < profile.getMonitorWindow()) {
+ long responsePendingCount = state.getResponsePendingCount().toJava();
+ if (responsePendingCount < profile.getMonitorWindow().toJava()) {
responsePendingCount = responsePendingCount + 1;
}
// Check with the failure threshold
- if (responsePendingCount >= profile.getFailureThreshold()) {
+ if (responsePendingCount >= profile.getFailureThreshold().toJava()) {
// Change the state to down and notify
if (currentLivenessState != LivenessState.Down) {
LOG.debug("Response pending Count: {}, Failure threshold: {} for monitorId {}",
// Close the transaction
tx.commit();
String errorMsg = String.format(
- "Monitoring State associated with id %d is not present to send packet out.", monitorId);
+ "Monitoring State associated with id %s is not present to send packet out.", monitorId);
return Futures.immediateFailedFuture(new RuntimeException(errorMsg));
}
}, callbackExecutorService);
}, callbackExecutorService);
}
- void publishNotification(final Long monitorId, final LivenessState state) {
+ void publishNotification(final Uint32 monitorId, final LivenessState state) {
LOG.debug("Sending notification for id {} - state {}", monitorId, state);
EventData data = new EventDataBuilder().setMonitorId(monitorId).setMonitorState(state).build();
MonitorEvent event = new MonitorEventBuilder().setEventData(data).build();
LOG.debug("Monitor Profile Create operation - {}", input.getProfile());
final SettableFuture<RpcResult<MonitorProfileCreateOutput>> returnFuture = SettableFuture.create();
Profile profile = input.getProfile();
- final Long failureThreshold = profile.getFailureThreshold();
- final Long monitorInterval = profile.getMonitorInterval();
- final Long monitorWindow = profile.getMonitorWindow();
+ final Uint32 failureThreshold = profile.getFailureThreshold();
+ final Uint32 monitorInterval = profile.getMonitorInterval();
+ final Uint32 monitorWindow = profile.getMonitorWindow();
final MonitorProtocolType protocolType = profile.getProtocolType();
String idKey = getUniqueProfileKey(failureThreshold, monitorInterval, monitorWindow, protocolType);
- final Long profileId = (long) getUniqueId(idKey);
+ final Uint32 profileId = Uint32.valueOf(getUniqueId(idKey));
final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
FluentFuture<Optional<MonitorProfile>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL,
org.opendaylight.yang.gen.v1.urn.opendaylight.genius
.alivenessmonitor.rev160411.monitor.profile.get.input.Profile profile = input
.getProfile();
- final Long failureThreshold = profile.getFailureThreshold();
- final Long monitorInterval = profile.getMonitorInterval();
- final Long monitorWindow = profile.getMonitorWindow();
+ final Uint32 failureThreshold = profile.getFailureThreshold();
+ final Uint32 monitorInterval = profile.getMonitorInterval();
+ final Uint32 monitorWindow = profile.getMonitorWindow();
final MonitorProtocolType protocolType = profile.getProtocolType();
LOG.debug("getExistingProfileId for profile : {}", input.getProfile());
String idKey = getUniqueProfileKey(failureThreshold, monitorInterval, monitorWindow, protocolType);
return (long) getUniqueId(idKey);
}
- private String getUniqueProfileKey(Long failureThreshold, Long monitorInterval, Long monitorWindow,
+ private String getUniqueProfileKey(Uint32 failureThreshold, Uint32 monitorInterval, Uint32 monitorWindow,
MonitorProtocolType protocolType) {
return String.valueOf(failureThreshold) + AlivenessMonitorConstants.SEPERATOR + monitorInterval
+ AlivenessMonitorConstants.SEPERATOR + monitorWindow + AlivenessMonitorConstants.SEPERATOR
final MonitorProfileDeleteInput input) {
LOG.debug("Monitor Profile delete for Id: {}", input.getProfileId());
final SettableFuture<RpcResult<MonitorProfileDeleteOutput>> result = SettableFuture.create();
- final Long profileId = input.getProfileId();
+ final Uint32 profileId = input.getProfileId();
final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
FluentFuture<Optional<MonitorProfile>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL,
getMonitorProfileId(profileId));
tx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
public void onFailure(Throwable error) {
- String msg = String.format("Error when removing monitor profile %d from datastore",
+ String msg = String.format("Error when removing monitor profile %s from datastore",
profileId);
LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>failed()
}
}, callbackExecutorService);
} else {
- String msg = String.format("Monitor profile with Id: %d does not exist", profileId);
+ String msg = String.format("Monitor profile with Id: %s does not exist", profileId);
LOG.info(msg);
result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>success()
.withWarning(ErrorType.PROTOCOL, "invalid-value", msg).build());
@Override
public void onFailure(Throwable error) {
- String msg = String.format("Error when removing monitor profile %d from datastore", profileId);
+ String msg = String.format("Error when removing monitor profile %s from datastore", profileId);
LOG.error("Error when removing monitor profile {} from datastore", profileId, error);
result.set(RpcResultBuilder.<MonitorProfileDeleteOutput>failed()
.withError(ErrorType.APPLICATION, msg, error).build());
LOG.debug("Monitor Stop operation for monitor id - {}", input.getMonitorId());
SettableFuture<RpcResult<MonitorStopOutput>> result = SettableFuture.create();
- final Long monitorId = input.getMonitorId();
+ final Uint32 monitorId = input.getMonitorId();
Optional<MonitoringInfo> optInfo;
try {
optInfo = txRunner.applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
if (monitorKey != null) {
tx.delete(getMonitorStateId(monitorKey));
- monitorIdKeyCache.invalidate(monitorId);
+ monitorIdKeyCache.invalidate(monitorId.toJava());
}
tx.delete(getMonitoringInfoId(monitorId));
//Remove monitorid-key-map
tx.delete(getMonitorMapId(monitorId));
- }).addCallback(new FutureCallbackImpl(String.format("Delete monitor state with Id %d", monitorId)),
+ }).addCallback(new FutureCallbackImpl("Delete monitor state with Id " + monitorId),
MoreExecutors.directExecutor());
MonitoringInfo info = optInfo.get();
result.set(RpcResultBuilder.<MonitorStopOutput>success().build());
} else {
- String errorMsg = String.format("Do not have monitoring information associated with key %d", monitorId);
+ String errorMsg = "Do not have monitoring information associated with key " + monitorId;
LOG.error("Delete monitoring operation Failed - {}", errorMsg);
result.set(RpcResultBuilder.<MonitorStopOutput>failed().withError(ErrorType.APPLICATION, errorMsg).build());
}
return result;
}
- private void removeMonitorIdFromInterfaceAssociation(final Long monitorId, final String interfaceName) {
+ private void removeMonitorIdFromInterfaceAssociation(final Uint32 monitorId, final String interfaceName) {
LOG.debug("Remove monitorId {} from Interface association {}", monitorId, interfaceName);
final ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
FluentFuture<Optional<InterfaceMonitorEntry>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL,
FluentFuture<? extends CommitInfo> updateFuture = readFuture.transformAsync(optEntry -> {
if (optEntry.isPresent()) {
InterfaceMonitorEntry entry = optEntry.get();
- List<Long> monitorIds =
+ List<Uint32> monitorIds =
entry.getMonitorIds() != null ? new ArrayList<>(entry.getMonitorIds()) : new ArrayList<>();
monitorIds.remove(monitorId);
if (monitorIds.isEmpty()) {
}, MoreExecutors.directExecutor());
updateFuture.addCallback(new FutureCallbackImpl(
- String.format("Dis-association of monitorId %d with Interface %s", monitorId, interfaceName)),
+ String.format("Dis-association of monitorId %s with Interface %s", monitorId, interfaceName)),
MoreExecutors.directExecutor());
}
private void releaseIdForMonitoringInfo(MonitoringInfo info) {
- Long monitorId = info.getId();
+ Uint32 monitorId = info.getId();
EndpointType source = info.getSource().getEndpointType();
String interfaceName = getInterfaceName(source);
if (!Strings.isNullOrEmpty(interfaceName)) {
return interfaceName;
}
- private void stopMonitoring(long monitorId) {
+ private void stopMonitoring(Uint32 monitorId) {
updateMonitorStatusTo(monitorId, MonitorStatus.Stopped,
currentStatus -> currentStatus != MonitorStatus.Stopped);
if (!stopMonitoringTask(monitorId)) {
}
}
- private void updateMonitorStatusTo(final Long monitorId, final MonitorStatus newStatus,
+ private void updateMonitorStatusTo(final Uint32 monitorId, final MonitorStatus newStatus,
final Predicate<MonitorStatus> isValidStatus) {
final String monitorKey = monitorIdKeyCache.getUnchecked(monitorId);
if (monitorKey == null) {
return tx.commit();
}, MoreExecutors.directExecutor());
- writeResult.addCallback(new FutureCallbackImpl(
- String.format("Monitor status update for %d to %s", monitorId, newStatus.toString())),
+ writeResult.addCallback(new FutureCallbackImpl("Monitor status update for " + monitorId + " to " + newStatus),
MoreExecutors.directExecutor());
}
- private void resumeMonitoring(final long monitorId) {
+ private void resumeMonitoring(final Uint32 monitorId) {
final ReadTransaction tx = dataBroker.newReadOnlyTransaction();
FluentFuture<Optional<MonitoringInfo>> readInfoResult = tx.read(LogicalDatastoreType.OPERATIONAL,
getMonitoringInfoId(monitorId));
@Override
public void onFailure(Throwable error) {
- String msg = String.format("Unable to read monitoring info associated with monitor id %d", monitorId);
+ String msg = "Unable to read monitoring info associated with monitor id " + monitorId;
LOG.error("Monitor resume Failed. {}", msg, error);
tx.close();
}
@Override
public void onFailure(Throwable error) {
- String msg = String.format("Unable to read Monitoring profile associated with id %d",
- info.getProfileId());
+ String msg = "Unable to read Monitoring profile associated with id " + info.getProfileId();
LOG.warn("Monitor resume Failed. {}", msg, error);
tx.close();
}
LOG.debug("Monitor Resume - Scheduling monitoring task for Id: {}", monitorId);
scheduleMonitoringTask(info, profile.getMonitorInterval());
} else {
- String msg = String.format("Monitoring profile associated with id %d is not present",
+ String msg = String.format("Monitoring profile associated with id %s is not present",
info.getProfileId());
LOG.warn("Monitor resume Failed. {}", msg);
}
}, MoreExecutors.directExecutor());
} else {
tx.close();
- String msg = String.format("Monitoring info associated with id %d is not present", monitorId);
+ String msg = String.format("Monitoring info associated with id %s is not present", monitorId);
LOG.warn("Monitor resume Failed. {}", msg);
}
}
@Override
public void onInterfaceStateUp(String interfaceName) {
- List<Long> monitorIds = getMonitorIds(interfaceName);
+ List<Uint32> monitorIds = getMonitorIds(interfaceName);
if (monitorIds.isEmpty()) {
LOG.warn("Could not get monitorId for interface: {}", interfaceName);
return;
}
- for (Long monitorId : monitorIds) {
+ for (Uint32 monitorId : monitorIds) {
LOG.debug("Resume monitoring on interface: {} with monitorId: {}", interfaceName, monitorId);
resumeMonitoring(monitorId);
}
@Override
public void onInterfaceStateDown(String interfaceName) {
- List<Long> monitorIds = getMonitorIds(interfaceName);
+ List<Uint32> monitorIds = getMonitorIds(interfaceName);
if (monitorIds.isEmpty()) {
LOG.warn("Could not get monitorIds for interface: {}", interfaceName);
return;
}
- for (Long monitorId : monitorIds) {
+ for (Uint32 monitorId : monitorIds) {
LOG.debug("Suspend monitoring on interface: {} with monitorId: {}", interfaceName, monitorId);
stopMonitoring(monitorId);
}
}
- private List<Long> getMonitorIds(String interfaceName) {
+ private List<Uint32> getMonitorIds(String interfaceName) {
try {
return txRunner.applyInterruptiblyWithNewReadOnlyTransactionAndClose(OPERATIONAL,
tx -> tx.read(getInterfaceMonitorMapId(interfaceName))).get().map(
@Override
public void remove(@NonNull InstanceIdentifier<MonitoringState> instanceIdentifier,
@NonNull MonitoringState removedDataObject) {
- final Long monitorId = removedDataObject.getMonitorId();
+ final Uint32 monitorId = removedDataObject.getMonitorId();
LOG.debug("Monitor State remove listener invoked for monitor id: {}", monitorId);
if (removedDataObject.getStatus() != MonitorStatus.Paused) {
public void update(@NonNull InstanceIdentifier<MonitoringState> instanceIdentifier,
@NonNull MonitoringState originalDataObject,
@NonNull MonitoringState updatedDataObject) {
- final Long monitorId = updatedDataObject.getMonitorId();
+ final Uint32 monitorId = updatedDataObject.getMonitorId();
LOG.debug("Monitor State update listener invoked for monitor id: {}", monitorId);
if (updatedDataObject.getStatus() == MonitorStatus.Paused
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
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.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
MonitorProfile profile;
- long profileId = monitorInfo.getProfileId();
+ Uint32 profileId = monitorInfo.getProfileId();
java.util.Optional<MonitorProfile> optProfile = alivenessMonitor.getMonitorProfile(profileId);
if (optProfile.isPresent()) {
profile = optProfile.get();
private void fillBfdParams(List<BfdParams> bfdParams, MonitorProfile profile) {
setBfdParamForEnable(bfdParams, true);
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_RX, Long.toString(profile.getMinRx())));
- bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_TX, Long.toString(profile.getMinTx())));
- bfdParams.add(
- getBfdParams(AlivenessMonitorConstants.BFD_PARAM_DECAY_MIN_RX, Long.toString(profile.getDecayMinRx())));
+ bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_RX,
+ Long.toString(profile.getMinRx().toJava())));
+ bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_MIN_TX,
+ Long.toString(profile.getMinTx().toJava())));
+ bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_DECAY_MIN_RX,
+ Long.toString(profile.getDecayMinRx().toJava())));
bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_FORWARDING_IF_RX, profile.getForwardingIfRx()));
bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CPATH_DOWN, profile.getCpathDown()));
bfdParams.add(getBfdParams(AlivenessMonitorConstants.BFD_PARAM_CHECK_TNL_KEY, profile.getCheckTnlKey()));
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.monitoring.states.MonitoringStateKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcError;
+import org.opendaylight.yangtools.yang.common.Uint32;
public final class AlivenessMonitorUtil {
private AlivenessMonitorUtil() {
.child(MonitoringState.class, new MonitoringStateKey(keyId)).build();
}
- public static InstanceIdentifier<MonitoringInfo> getMonitoringInfoId(Long monitorId) {
+ public static InstanceIdentifier<MonitoringInfo> getMonitoringInfoId(Uint32 monitorId) {
return InstanceIdentifier.builder(MonitorConfigs.class)
.child(MonitoringInfo.class, new MonitoringInfoKey(monitorId)).build();
}
- public static InstanceIdentifier<MonitorProfile> getMonitorProfileId(Long profileId) {
+ public static InstanceIdentifier<MonitorProfile> getMonitorProfileId(Uint32 profileId) {
return InstanceIdentifier.builder(MonitorProfiles.class)
.child(MonitorProfile.class, new MonitorProfileKey(profileId)).build();
}
- public static InstanceIdentifier<MonitoridKeyEntry> getMonitorMapId(Long keyId) {
+ public static InstanceIdentifier<MonitoridKeyEntry> getMonitorMapId(Uint32 keyId) {
return InstanceIdentifier.builder(MonitoridKeyMap.class)
.child(MonitoridKeyEntry.class, new MonitoridKeyEntryKey(keyId)).build();
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.arputil.internal;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import java.io.UnsupportedEncodingException;
-import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.genius.arputil.api.ArpConstants;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public ListenableFuture<RpcResult<SendArpRequestOutput>> sendArpRequest(SendArpRequestInput arpReqInput) {
LOG.trace("rpc sendArpRequest invoked for ip {}", arpReqInput.getIpaddress());
- BigInteger dpnId;
+ Uint64 dpnId;
byte[] payload;
String interfaceName = null;
byte[] srcIpBytes;
GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
checkNotNull(portResult);
dpnId = portResult.getDpid();
- Long portid = portResult.getPortno();
- checkArgument(null != dpnId && !BigInteger.ZERO.equals(dpnId),
+ Long portid = portResult.getPortno().toJava();
+ checkArgument(null != dpnId && !Uint64.ZERO.equals(dpnId),
ArpConstants.DPN_NOT_FOUND_ERROR, interfaceName);
NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId, portid.toString());
}
public ListenableFuture<RpcResult<TransmitPacketOutput>> sendPacketOut(
- BigInteger dpnId, byte[] payload, NodeConnectorRef ref) {
+ Uint64 dpnId, byte[] payload, NodeConnectorRef ref) {
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
return packetProcessingService.transmitPacket(new TransmitPacketInputBuilder().setPayload(payload)
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
}
private Future<RpcResult<TransmitPacketOutput>> sendPacketOutWithActions(
-
BigInteger dpnId, byte[] payload, NodeConnectorRef ref, List<Action> actions) {
+
Uint64 dpnId, byte[] payload, NodeConnectorRef ref, List<Action> actions) {
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
TransmitPacketInput transmitPacketInput = new TransmitPacketInputBuilder().setPayload(payload)
.setNode(new NodeRef(InstanceIdentifier.builder(Nodes.class)
@Override
public ListenableFuture<RpcResult<SendArpResponseOutput>> sendArpResponse(SendArpResponseInput input) {
LOG.trace("sendArpResponse rpc invoked");
- BigInteger dpnId;
+ Uint64 dpnId;
byte[] payload;
byte[] srcMac;
GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
checkNotNull(portResult);
dpnId = portResult.getDpid();
- Long portid = portResult.getPortno();
+ Long portid = portResult.getPortno().toJava();
NodeConnectorRef ref = MDSALUtil.getNodeConnRef(dpnId, portid.toString());
- checkArgument(null != dpnId && !BigInteger.ZERO.equals(dpnId),
+ checkArgument(null != dpnId && !Uint64.ZERO.equals(dpnId),
ArpConstants.DPN_NOT_FOUND_ERROR, interfaceName);
checkNotNull(ref, ArpConstants.NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
byte[] srcIpBytes = getIpAddressBytes(input.getSrcIpaddress());
byte[] dstIpBytes = getIpAddressBytes(input.getDstIpaddress());
if (input.getSrcMacaddress() == null) {
- srcMac = portResult.getPhyAddress().getBytes("UTF-8");
+ srcMac = portResult.getPhyAddress().getBytes(StandardCharsets.UTF_8);
} else {
String macAddr = input.getSrcMacaddress().getValue();
srcMac = HexEncode.bytesFromHexString(macAddr);
input.getSrcIpaddress().getIpv4Address().getValue(), HexEncode.bytesToHexStringFormat(srcMac),
HexEncode.bytesToHexStringFormat(dstMac), input.getDstIpaddress().getIpv4Address().getValue(),
dpnId);
- } catch (UnknownHostException | PacketException | InterruptedException | UnsupportedEncodingException
- | ExecutionException e) {
+ } catch (UnknownHostException | PacketException | InterruptedException | ExecutionException e) {
LOG.error("failed to send arp response for {}: ", input.getSrcIpaddress(), e);
return RpcResultBuilder.<SendArpResponseOutput>failed()
.withError(ErrorType.APPLICATION, e.getMessage(), e).buildFuture();
if (pktInReason == SendToController.class) {
try {
- BigInteger dpnId = extractDpnId(packetReceived);
- int tableId = packetReceived.getTableId().getValue();
+ Uint64 dpnId = extractDpnId(packetReceived);
+ int tableId = packetReceived.getTableId().getValue().toJava();
byte[] data = packetReceived.getPayload();
Ethernet ethernet = new Ethernet();
LOG.debug("metadata received is {} ", metadata);
GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
- BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
+ Uint64 lportTag = MetaDataUtil.getLportFromMetadata(metadata.getMetadata());
ifIndexInputBuilder.setIfIndex(lportTag.intValue());
GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
}
private void fireArpRespRecvdNotification(String interfaceName, InetAddress srcInetAddr, byte[] srcMacAddressBytes,
- BigInteger dpnId, int tableId, BigInteger metadata, InetAddress dstInetAddr, byte[] dstMacAddressBytes)
+ Uint64 dpnId, int tableId, Uint64 metadata, InetAddress dstInetAddr, byte[] dstMacAddressBytes)
throws InterruptedException {
arpRespRecvd.mark();
}
private void fireArpReqRecvdNotification(String interfaceName, InetAddress srcInetAddr, byte[] srcMac,
- InetAddress dstInetAddr, BigInteger dpnId, int tableId, BigInteger metadata) throws InterruptedException {
+ InetAddress dstInetAddr, Uint64 dpnId, int tableId, Uint64 metadata) throws InterruptedException {
arpReqRecvd.mark();
String macAddress = NWUtil.toStringMacAddress(srcMac);
ArpRequestReceivedBuilder builder = new ArpRequestReceivedBuilder();
}
}
- private BigInteger extractDpnId(PacketReceived packetReceived) {
+ private Uint64 extractDpnId(PacketReceived packetReceived) {
NodeKey nodeKey = packetReceived.getIngress().getValue().firstKeyOf(Node.class);
String nodeKeyString = nodeKey.getId().getValue();
return null;
}
- return new BigInteger(nodeKeyString.substring(OPENFLOW_PFX.length()));
+ return Uint64.valueOf(nodeKeyString.substring(OPENFLOW_PFX.length()));
}
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
- <version>${openflowplugin.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
*/
package org.opendaylight.genius.cloudscaler.api;
-import java.math.BigInteger;
import java.util.List;
import java.util.function.Function;
-
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface TombstonedNodeManager {
* @return true if the supllied dpn is getting scaled in
* @throws ReadFailedException throws read failed exception
*/
- boolean isDpnTombstoned(BigInteger dpnId) throws ReadFailedException;
+ boolean isDpnTombstoned(Uint64 dpnId) throws ReadFailedException;
/**
* Add the listener callback which will be invoked upon recovery of scaled in dpn.
* @param callback callback to be invoked on recovery
*/
- void addOnRecoveryCallback(Function<BigInteger, Void> callback);
+ void addOnRecoveryCallback(Function<Uint64, Void> callback);
/**
* Filters the list of dpns which are not scaled in.
* @return filtered list of dpns which are not scaled in
* @throws ReadFailedException throws read failed exception
*/
- List<BigInteger> filterTombStoned(List<BigInteger> dpns) throws ReadFailedException;
+ List<Uint64> filterTombStoned(List<Uint64> dpns) throws ReadFailedException;
}
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-service</artifactId>
- <version>${openflowplugin.version}</version>
</dependency>
<dependency>
<groupId>commons-net</groupId>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>caches-api</artifactId>
- <version>${genius.infrautils.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<dependency>
<groupId>org.opendaylight.openflowplugin</groupId>
<artifactId>openflowplugin-extension-nicira</artifactId>
- <version>${openflowplugin.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.openflowplugin.model</groupId>
<artifactId>model-flow-base</artifactId>
- <version>${openflowplugin.version}</version>
</dependency>
</dependencies>
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-
-import java.math.BigInteger;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Singleton;
-
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.ReadWriteTransaction;
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.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static RpcResult<ScaleinComputesEndOutput> DONE_RPC_RESPONSE = RpcResultBuilder
.<ScaleinComputesEndOutput>success().withResult(DONE).build();
- private DataBroker dataBroker;
+ private final DataBroker dataBroker;
private final ComputeNodeManager computeNodeManager;
private final ManagedNewTransactionRunner txRunner;
private final ItmTepClusteredListener itmTepClusteredListener;
//The following timestamp is not persisted across reboots
//upon reboot the timestamp will have a default value of that system timestamp
//this way scalein end that is triggered after cluster reboot will still honour the 2 min delay
- private LoadingCache<BigInteger, Long> tepDeleteTimeStamp = CacheBuilder.newBuilder()
+ private final LoadingCache<Uint64, Long> tepDeleteTimeStamp = CacheBuilder.newBuilder()
.expireAfterWrite(60, TimeUnit.MINUTES)
- .build(new CacheLoader<BigInteger, Long>() {
- public Long load(BigInteger dpnId) {
+ .build(new CacheLoader<Uint64, Long>() {
+ @Override
+ public Long load(Uint64 dpnId) {
return System.currentTimeMillis();
}
});
- public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<Void>() {
+ public static final FutureCallback<Void> DEFAULT_CALLBACK = new FutureCallback<>() {
@Override
public void onSuccess(Void result) {
LOG.debug("Success in Datastore operation");
}
Long tepDeletedTimeStamp = tepDeleteTimeStamp.get(computeNode.getDpnid());
Long currentTime = System.currentTimeMillis();
- if ((currentTime - tepDeletedTimeStamp) > DELETE_DELAY * 1000L) {
+ if (currentTime - tepDeletedTimeStamp > DELETE_DELAY * 1000L) {
scaleinComputesEnd2(input);
} else {
return Futures.immediateFuture(IN_PROGRESS_RPC_RESPONSE);
package org.opendaylight.genius.cloudscaler.rpcservice;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
-import java.math.BigInteger;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final DataBroker dataBroker;
- private InstanceIdDataObjectCache<ComputeNode> computeNodeCache;
- private InstanceIdDataObjectCache<Node> ovsdbTopologyNodeCache;
- private Map<BigInteger, ComputeNode> dpnIdVsComputeNode;
- private ExecutorService executorService = Executors.newSingleThreadExecutor("compute-node-manager", LOG);
+ private final InstanceIdDataObjectCache<ComputeNode> computeNodeCache;
+ private final InstanceIdDataObjectCache<Node> ovsdbTopologyNodeCache;
+ private final Map<Uint64, ComputeNode> dpnIdVsComputeNode;
+ // FIXME: this service is never shut down
+ private final ExecutorService executorService = Executors.newSingleThreadExecutor("compute-node-manager", LOG);
@Inject
@SuppressFBWarnings({"URF_UNREAD_FIELD", "NP_LOAD_OF_KNOWN_NULL_VALUE"})
CacheProvider cacheProvider) {
this.dataBroker = dataBroker;
this.dpnIdVsComputeNode = new ConcurrentHashMap<>();
- this.computeNodeCache = new InstanceIdDataObjectCache<ComputeNode>(ComputeNode.class, dataBroker,
+ this.computeNodeCache = new InstanceIdDataObjectCache<>(ComputeNode.class, dataBroker,
LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(ComputeNodes.class).child(ComputeNode.class).build(),
cacheProvider) {
dpnIdVsComputeNode.remove(computeNode.getDpnid());
}
};
- this.ovsdbTopologyNodeCache = new InstanceIdDataObjectCache<Node>(Node.class, dataBroker,
+ this.ovsdbTopologyNodeCache = new InstanceIdDataObjectCache<>(Node.class, dataBroker,
LogicalDatastoreType.OPERATIONAL,
getWildcardPath(),
cacheProvider) {
public void add(@NonNull Node node) throws TransactionCommitFailedException {
OvsdbBridgeAugmentation bridgeAugmentation = node.augmentation(OvsdbBridgeAugmentation.class);
if (bridgeAugmentation != null && bridgeAugmentation.getBridgeOtherConfigs() != null) {
- BigInteger datapathid = getDpnIdFromBridge(bridgeAugmentation);
+ Uint64 datapathid = getDpnIdFromBridge(bridgeAugmentation);
Optional<BridgeOtherConfigs> otherConfigOptional = bridgeAugmentation.getBridgeOtherConfigs()
.stream()
.filter(otherConfig -> otherConfig.getBridgeOtherConfigKey().equals("dp-desc"))
.build();
}
- private BigInteger getDpnIdFromBridge(OvsdbBridgeAugmentation bridgeAugmentation) {
+ private Uint64 getDpnIdFromBridge(OvsdbBridgeAugmentation bridgeAugmentation) {
String datapathIdStr = bridgeAugmentation.getDatapathId().getValue().replace(":", "");
- return new BigInteger(datapathIdStr, 16);
+ return Uint64.valueOf(datapathIdStr, 16);
}
public void putComputeDetailsInConfigDatastore(InstanceIdentifier<ComputeNode> computeIid,
//LOG.info("Write comute node details {}", computeNode);
}
- private void logErrorIfComputeNodeIsAlreadyTaken(BigInteger datapathid, String nodeId,
+ private void logErrorIfComputeNodeIsAlreadyTaken(Uint64 datapathid, String nodeId,
com.google.common.base.Optional<ComputeNode> optional) {
ComputeNode existingNode = optional.get();
if (!Objects.equals(existingNode.getNodeid(), nodeId)) {
.child(Node.class);
}
- public ComputeNode getComputeNode(BigInteger dpnId) {
+ public ComputeNode getComputeNode(Uint64 dpnId) {
return dpnIdVsComputeNode.get(dpnId);
}
}
*/
package org.opendaylight.genius.cloudscaler.rpcservice;
-import java.math.BigInteger;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.ComputeNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.cloudscaler.rpcs.rev171220.compute.nodes.ComputeNode;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final DataBroker dataBroker;
private final CacheProvider cacheProvider;
- private final Set<Function<BigInteger, Void>> callbacks = ConcurrentHashMap.newKeySet();
+ private final Set<Function<Uint64, Void>> callbacks = ConcurrentHashMap.newKeySet();
private final ComputeNodeManager computeNodeManager;
private InstanceIdDataObjectCache<ComputeNode> computeNodeCache;
- private ExecutorService executorService = Executors.newSingleThreadExecutor("tombstone-node-manager", LOG);
+ // FIXME: this service is never shut down
+ private final ExecutorService executorService = Executors.newSingleThreadExecutor("tombstone-node-manager", LOG);
@Inject
public TombstonedNodeManagerImpl(DataBroker dataBroker,
}
void init() {
- this.computeNodeCache = new InstanceIdDataObjectCache<ComputeNode>(ComputeNode.class, dataBroker,
+ this.computeNodeCache = new InstanceIdDataObjectCache<>(ComputeNode.class, dataBroker,
LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(ComputeNodes.class).child(ComputeNode.class).build(),
cacheProvider) {
}
@Override
- public boolean isDpnTombstoned(BigInteger dpnId) throws ReadFailedException {
+ public boolean isDpnTombstoned(Uint64 dpnId) throws ReadFailedException {
if (dpnId == null) {
return false;
}
}
@Override
- public void addOnRecoveryCallback(Function<BigInteger, Void> callback) {
+ public void addOnRecoveryCallback(Function<Uint64, Void> callback) {
callbacks.add(callback);
}
@Override
- public List<BigInteger> filterTombStoned(List<BigInteger> dpns) throws ReadFailedException {
+ public List<Uint64> filterTombStoned(List<Uint64> dpns) throws ReadFailedException {
return dpns.stream().filter((dpn) -> {
try {
return !isDpnTombstoned(dpn);
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.ListenableFuture;
-
import java.math.BigInteger;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-
import javax.inject.Inject;
-
import org.awaitility.Awaitility;
import org.awaitility.core.ConditionFactory;
import org.junit.Before;
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.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final String NODEID2 = "ovsdb://uuid/2de70a99-29a5-4f2a-b87e-96d6ed57e412/bridge/br-int";
private static final String NODEID3 = "ovsdb://uuid/2de70a99-29a5-4f2a-b87e-96d6ed57e413/bridge/br-int";
- private static final BigInteger DPN1 = new BigInteger("1");
- private static final BigInteger DPN2 = new BigInteger("2");
- private static final BigInteger DPN3 = new BigInteger("3");
- private static final BigInteger DPN4 = new BigInteger("4");
+ private static final Uint64 DPN1 = Uint64.ONE;
+ private static final Uint64 DPN2 = Uint64.valueOf(2);
+ private static final Uint64 DPN3 = Uint64.valueOf(3);
+ private static final Uint64 DPN4 = Uint64.valueOf(4);
private static final String DPN1_DATAPATHID = new String("00:00:00:00:00:00:00:01");
private static final String DPN2_DATAPATHID = new String("00:00:00:00:00:00:00:02");
}
private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node>
- buildOpenflowNodeIid(BigInteger dpnid) {
+ buildOpenflowNodeIid(Uint64 dpnid) {
return InstanceIdentifier.builder(Nodes.class)
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey(
}
private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node buildOpenflowNode(
- BigInteger dpnId) {
+ Uint64 dpnId) {
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder
= new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder();
nodeBuilder.setId(new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(
throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
testScaleinComputesStartRpc();
- List<BigInteger> filtered = tombstonedNodeManager.filterTombStoned(Lists.newArrayList(DPN1, DPN2, DPN3, DPN4));
+ List<Uint64> filtered = tombstonedNodeManager.filterTombStoned(Lists.newArrayList(DPN1, DPN2, DPN3, DPN4));
assertTrue("Dpn 1 and 2 should be filtered ",
Sets.difference(Sets.newHashSet(DPN3, DPN4), Sets.newHashSet(filtered)).isEmpty());
}
@Test public void testRecoveryCallback()
throws ExecutionException, InterruptedException, ReadFailedException, TransactionCommitFailedException {
- Set<BigInteger> nodesRecoverd = new HashSet<>();
+ Set<Uint64> nodesRecoverd = new HashSet<>();
tombstonedNodeManager.addOnRecoveryCallback((dpnId) -> {
nodesRecoverd.add(dpnId);
return null;
AWAITER.until(() -> nodesRecoverd.contains(DPN1));
}
- private BridgeRefEntry buildBridgeRefEntry(BigInteger dpnId, String nodeId) {
+ private BridgeRefEntry buildBridgeRefEntry(Uint64 dpnId, String nodeId) {
return new BridgeRefEntryBuilder()
.setDpid(dpnId)
.setBridgeReference(new OvsdbBridgeRef(buildNodeIid(nodeId)))
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>4.0.6</version>
+ <version>5.0.3</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>3.0.5</version>
+ <version>4.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>4.0.6</version>
+ <version>5.0.3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
-import java.math.BigInteger;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.genius.testutils.interfacemanager.InterfaceStateHelper;
import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* IInterfaceManager implementation for tests.
}
@Override
- public BigInteger getDpnForInterface(String interfaceName) {
+ public Uint64 getDpnForInterface(String interfaceName) {
return interfaceInfos.get(interfaceName).getDpId();
}
@Override
- public BigInteger getDpnForInterface(Interface intrface) {
+ public Uint64 getDpnForInterface(Interface intrface) {
return interfaceInfos.get(intrface.getName()).getDpId();
}
package org.opendaylight.genius.testutils.interfacemanager;
import com.google.common.collect.Lists;
-import java.math.BigInteger;
-
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
-
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.Other;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class InterfaceStateHelper {
}
public static Interface buildStateFromInterfaceInfo(InterfaceInfo interfaceInfo) {
- BigInteger dpId = interfaceInfo.getDpId();
+ Uint64 dpId = interfaceInfo.getDpId();
int portno = interfaceInfo.getPortNo();
- NodeConnectorId nodeConnectorId = new NodeConnectorId("openflow:" + dpId.toString() + ":" + portno);
+ NodeConnectorId nodeConnectorId = new NodeConnectorId("openflow:" + dpId + ":" + portno);
return new InterfaceBuilder()
.setType(Other.class)
.setIfIndex(interfaceInfo.getInterfaceTag())
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
-
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.SetBfdParamOnTunnelOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class ItmRpcTestImpl implements ItmRpcService {
- private final Map<BigInteger, IpAddress> tepIps = new ConcurrentHashMap<>();
- private final Map<BigInteger, Map<String, String>> interfaceNames = new ConcurrentHashMap<>();
- private final Map<BigInteger, Map<String, String>> externalInterfaceNames = new ConcurrentHashMap<>();
+ // FIXME: access is complete synchronized, why are these ConcurrentHashMaps???
+ private final Map<Uint64, IpAddress> tepIps = new ConcurrentHashMap<>();
+ private final Map<Uint64, Map<String, String>> interfaceNames = new ConcurrentHashMap<>();
+ private final Map<Uint64, Map<String, String>> externalInterfaceNames = new ConcurrentHashMap<>();
- public synchronized void addDpn(BigInteger dpnId, String tepIp) {
+ public synchronized void addDpn(Uint64 dpnId, String tepIp) {
tepIps.put(dpnId, IpAddressBuilder.getDefaultInstance(tepIp));
}
- public synchronized void addInterface(BigInteger dpnId, String dstTep, String interfaceName) {
+ public synchronized void addInterface(Uint64 dpnId, String dstTep, String interfaceName) {
interfaceNames.putIfAbsent(dpnId, new ConcurrentHashMap<>());
interfaceNames.get(dpnId).put(dstTep, interfaceName);
}
- public synchronized void addL2GwInterface(BigInteger dpnId, String nodeId, String interfaceName) {
+ public synchronized void addL2GwInterface(Uint64 dpnId, String nodeId, String interfaceName) {
externalInterfaceNames.putIfAbsent(dpnId, new ConcurrentHashMap<>());
externalInterfaceNames.get(dpnId).put(nodeId, interfaceName);
}
- public synchronized void addExternalInterface(BigInteger dpnId, String dstTep, String interfaceName) {
+ public synchronized void addExternalInterface(Uint64 dpnId, String dstTep, String interfaceName) {
//dstTep = IpAddressBuilder.getDefaultInstance(dstTep).toString();
externalInterfaceNames.putIfAbsent(dpnId, new ConcurrentHashMap<>());
externalInterfaceNames.get(dpnId).put(dstTep, interfaceName);
@Override
public synchronized ListenableFuture<RpcResult<GetExternalTunnelInterfaceNameOutput>>
getExternalTunnelInterfaceName(GetExternalTunnelInterfaceNameInput input) {
- String interfaceName = externalInterfaceNames.get(new BigInteger(input.getSourceNode(), 10))
+ String interfaceName = externalInterfaceNames.get(Uint64.valueOf(input.getSourceNode()))
.get(input.getDestinationNode());
GetExternalTunnelInterfaceNameOutput output = new GetExternalTunnelInterfaceNameOutputBuilder()
.setInterfaceName(interfaceName)
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
*/
package org.opendaylight.genius.fcapsmanager.alarmmanager;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.management.ManagementFactory;
import java.util.Set;
import java.util.TreeSet;
* Platform dependent bundle injects its handle and it is retrieved in the
* method.
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private AlarmServiceFacade getAlarmServiceSPI() {
AlarmServiceFacade service = null;
if (context != null) {
*/
package org.opendaylight.genius.fcapsmanager.countermanager;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.management.ManagementFactory;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
/**
* Platform dependent bundle injects its handle and it is retrieved in the method.
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private PMServiceFacade getPMServiceSPI() {
PMServiceFacade service = null;
if (bundleContext != null) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>4.0.6</version>
+ <version>5.0.3</version>
<scope>import</scope>
<type>pom</type>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-genius-api">
<feature name="odl-genius-api">
- <feature version="[5,6)">odl-apache-commons-net</feature>
+ <feature version="[6,7)">odl-apache-commons-net</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public boolean updateLocalIdPoolCache(IdPool idPool, String parentPoolName) {
AvailableIdsHolder availableIdsHolder = idPool.getAvailableIdsHolder();
- AvailableIdHolder availableIdHolder = new AvailableIdHolder(idUtils, availableIdsHolder.getStart(),
- availableIdsHolder.getEnd());
+ AvailableIdHolder availableIdHolder = new AvailableIdHolder(idUtils, availableIdsHolder.getStart().toJava(),
+ availableIdsHolder.getEnd().toJava());
availableIdHolder.setCur(availableIdsHolder.getCursor());
ReleasedIdsHolder releasedIdsHolder = idPool.getReleasedIdsHolder();
- ReleasedIdHolder releasedIdHolder = new ReleasedIdHolder(idUtils, releasedIdsHolder.getDelayedTimeSec());
- releasedIdHolder.setAvailableIdCount(releasedIdsHolder.getAvailableIdCount());
+ ReleasedIdHolder releasedIdHolder = new ReleasedIdHolder(idUtils,
+ releasedIdsHolder.getDelayedTimeSec().toJava());
+ releasedIdHolder.setAvailableIdCount(releasedIdsHolder.getAvailableIdCount().toJava());
List<DelayedIdEntry> delayedIdEntryInCache = releasedIdsHolder.nonnullDelayedIdEntries()
.stream()
.map(delayedIdEntry -> new DelayedIdEntry(delayedIdEntry
- .getId(), delayedIdEntry.getReadyTimeSec()))
+ .getId().toJava(), delayedIdEntry.getReadyTimeSec().toJava()))
.sorted(comparing(DelayedIdEntry::getReadyTimeSec))
.collect(toCollection(ArrayList::new));
@Override
public ListenableFuture<RpcResult<CreateIdPoolOutput>> createIdPool(CreateIdPoolInput input) {
LOG.info("createIdPool called with input {}", input);
- long low = input.getLow();
- long high = input.getHigh();
+ long low = input.getLow().toJava();
+ long high = input.getHigh().toJava();
long blockSize = idUtils.computeBlockSize(low, high);
return FutureRpcResults.fromListenableFuture(LOG, "createIdPool", input, () -> {
String poolName = input.getPoolName().intern();
return FutureRpcResults.fromBuilder(LOG, "allocateId", input, () -> {
String localPoolName = idUtils.getLocalPoolName(poolName);
// allocateIdFromLocalPool method returns a list of IDs with one element. This element is obtained by get(0)
- long newIdValue = allocateIdFromLocalPool(poolName, localPoolName, idKey, 1).get(0);
+ long newIdValue = allocateIdFromLocalPool(poolName, localPoolName, idKey, 1).get(0).toJava();
return new AllocateIdOutputBuilder().setIdValue(newIdValue);
}).onFailure(e -> completeExceptionallyIfPresent(poolName, idKey, e)).build();
}
private void completeExceptionallyIfPresent(String poolName, String idKey, Throwable exception) {
- CompletableFuture<List<Long>> completableFuture =
+ CompletableFuture<List<Uint32>> completableFuture =
idUtils.removeAllocatedIds(idUtils.getUniqueKey(poolName, idKey));
if (completableFuture != null) {
completableFuture.completeExceptionally(exception);
public ListenableFuture<RpcResult<AllocateIdRangeOutput>> allocateIdRange(AllocateIdRangeInput input) {
String idKey = input.getIdKey();
String poolName = input.getPoolName();
- long size = input.getSize();
+ long size = input.getSize().toJava();
String localPoolName = idUtils.getLocalPoolName(poolName);
AllocateIdRangeOutputBuilder output = new AllocateIdRangeOutputBuilder();
return FutureRpcResults.fromBuilder(LOG, "allocateIdRange", input, () -> {
- List<Long> newIdValuesList = allocateIdFromLocalPool(poolName, localPoolName, idKey, size);
+ List<Uint32> newIdValuesList = allocateIdFromLocalPool(poolName, localPoolName, idKey, size);
Collections.sort(newIdValuesList);
output.setIdValues(newIdValuesList);
return output;
}).build();
}
- private List<Long> allocateIdFromLocalPool(String parentPoolName, String localPoolName,
+ private List<Uint32> allocateIdFromLocalPool(String parentPoolName, String localPoolName,
String idKey, long size) throws OperationFailedException, IdManagerException {
LOG.debug("Allocating id from local pool {}. Parent pool {}. Idkey {}", localPoolName, parentPoolName, idKey);
String uniqueIdKey = idUtils.getUniqueKey(parentPoolName, idKey);
- CompletableFuture<List<Long>> futureIdValues = new CompletableFuture<>();
- CompletableFuture<List<Long>> existingFutureIdValue =
+ CompletableFuture<List<Uint32>> futureIdValues = new CompletableFuture<>();
+ CompletableFuture<List<Uint32>> existingFutureIdValue =
idUtils.putAllocatedIdsIfAbsent(uniqueIdKey, futureIdValues);
if (existingFutureIdValue != null) {
try {
}
}
try {
- List<Long> newIdValuesList = checkForIdInIdEntries(parentPoolName, idKey, uniqueIdKey, futureIdValues,
+ List<Uint32> newIdValuesList = checkForIdInIdEntries(parentPoolName, idKey, uniqueIdKey, futureIdValues,
false);
if (!newIdValuesList.isEmpty()) {
return newIdValuesList;
localPoolName = localPoolName.intern();
if (size == 1) {
newIdValue = getIdFromLocalPoolCache(localIdPool, parentPoolName);
- newIdValuesList.add(newIdValue);
+ newIdValuesList.add(Uint32.valueOf(newIdValue));
} else {
getRangeOfIds(parentPoolName, localPoolName, size, newIdValuesList, localIdPool, newIdValue);
}
private long allocateIdBlockFromParentPool(IdLocalPool localPoolCache, IdPool parentIdPool,
TypedWriteTransaction<Configuration> confTx)
throws OperationFailedException, IdManagerException {
- long idCount;
+
+ long idCount = allocateIdBlockFromAvailableIdsHolder(localPoolCache, parentIdPool, confTx);
+ if (idCount > 0) {
+ return idCount;
+ }
+
ReleasedIdsHolderBuilder releasedIdsBuilderParent = IdUtils.getReleaseIdsHolderBuilder(parentIdPool);
+ final List<DelayedIdEntries> delayedEntries = releasedIdsBuilderParent.getDelayedIdEntries();
+ if (delayedEntries != null) {
+ releasedIdsBuilderParent.setDelayedIdEntries(new ArrayList<>(delayedEntries));
+ }
+
while (true) {
- idCount = allocateIdBlockFromAvailableIdsHolder(localPoolCache, parentIdPool, confTx);
- if (idCount > 0) {
- return idCount;
- }
idCount = allocateIdBlockFromReleasedIdsHolder(localPoolCache, releasedIdsBuilderParent, parentIdPool,
confTx);
if (idCount > 0) {
}
throw new IdManagerException(String.format("Ids exhausted for pool : %s", parentIdPool.getPoolName()));
}
+
+ idCount = allocateIdBlockFromAvailableIdsHolder(localPoolCache, parentIdPool, confTx);
+ if (idCount > 0) {
+ return idCount;
+ }
}
}
childPoolsList.sort(comparing(ChildPools::getLastAccessTime));
long currentTime = System.currentTimeMillis() / 1000;
for (ChildPools childPools : childPoolsList) {
- if (childPools.getLastAccessTime() + DEFAULT_IDLE_TIME > currentTime) {
+ if (childPools.getLastAccessTime().toJava() + DEFAULT_IDLE_TIME > currentTime) {
break;
}
if (!Objects.equals(childPools.getChildPoolName(), idUtils.getLocalPoolName(parentIdPool.getPoolName()))) {
long totalAvailableIdCount = releasedIds.getDelayedIdEntries().size()
+ idUtils.getAvailableIdsCount(availableIds);
- long count = releasedIdsBuilderParent.getAvailableIdCount() + totalAvailableIdCount;
+ long count = releasedIdsBuilderParent.getAvailableIdCount().toJava() + totalAvailableIdCount;
releasedIdsBuilderParent.setDelayedIdEntries(delayedIdEntriesParent).setAvailableIdCount(count);
singleTxDB.syncUpdate(LogicalDatastoreType.CONFIGURATION, idPoolInstanceIdentifier,
new IdPoolBuilder().withKey(new IdPoolKey(otherChildPool.getPoolName()))
private long allocateIdBlockFromReleasedIdsHolder(IdLocalPool localIdPool,
ReleasedIdsHolderBuilder releasedIdsBuilderParent, IdPool parentIdPool,
TypedWriteTransaction<Configuration> confTx) {
- if (releasedIdsBuilderParent.getAvailableIdCount() == 0) {
+ if (releasedIdsBuilderParent.getAvailableIdCount().toJava() == 0) {
LOG.debug("Ids unavailable in releasedIds of parent pool {}", parentIdPool);
return 0;
}
List<DelayedIdEntries> delayedIdEntriesParent = releasedIdsBuilderParent.getDelayedIdEntries();
- int idCount = Math.min(delayedIdEntriesParent.size(), parentIdPool.getBlockSize());
+ int idCount = Math.min(delayedIdEntriesParent.size(), parentIdPool.getBlockSize().toJava());
List<DelayedIdEntries> idEntriesToBeRemoved = delayedIdEntriesParent.subList(0, idCount);
ReleasedIdHolder releasedIds = (ReleasedIdHolder) localIdPool.getReleasedIds();
List<DelayedIdEntry> delayedIdEntriesLocalCache = releasedIds.getDelayedEntries();
List<DelayedIdEntry> delayedIdEntriesFromParentPool = idEntriesToBeRemoved
.stream()
.map(delayedIdEntry -> new DelayedIdEntry(delayedIdEntry
- .getId(), delayedIdEntry.getReadyTimeSec()))
+ .getId().toJava(), delayedIdEntry.getReadyTimeSec().toJava()))
.sorted(comparing(DelayedIdEntry::getReadyTimeSec))
.collect(toCollection(ArrayList::new));
delayedIdEntriesFromParentPool.addAll(delayedIdEntriesLocalCache);
InstanceIdentifier<ReleasedIdsHolder> releasedIdsHolderInstanceIdentifier = InstanceIdentifier
.builder(IdPools.class).child(IdPool.class,
new IdPoolKey(parentIdPool.getPoolName())).child(ReleasedIdsHolder.class).build();
- releasedIdsBuilderParent.setAvailableIdCount(releasedIdsBuilderParent.getAvailableIdCount() - idCount);
+ releasedIdsBuilderParent.setAvailableIdCount(releasedIdsBuilderParent.getAvailableIdCount().toJava() - idCount);
LOG.debug("Allocated {} ids from releasedIds of parent pool {}", idCount, parentIdPool);
confTx.merge(releasedIdsHolderInstanceIdentifier, releasedIdsBuilderParent.build(), CREATE_MISSING_PARENTS);
return idCount;
TypedWriteTransaction<Configuration> confTx) {
long idCount = 0;
AvailableIdsHolderBuilder availableIdsBuilderParent = idUtils.getAvailableIdsHolderBuilder(parentIdPool);
- long end = availableIdsBuilderParent.getEnd();
+ long end = availableIdsBuilderParent.getEnd().toJava();
long cur = availableIdsBuilderParent.getCursor();
if (!idUtils.isIdAvailable(availableIdsBuilderParent)) {
if (LOG.isDebugEnabled()) {
return idCount;
}
// Update availableIdsHolder of Local Pool
- idCount = Math.min(end - cur, parentIdPool.getBlockSize());
+ idCount = Math.min(end - cur, parentIdPool.getBlockSize().toJava());
AvailableIdHolder availableIds = new AvailableIdHolder(idUtils, cur + 1, cur + idCount);
localIdPool.setAvailableIds(availableIds);
// Update availableIdsHolder of Global Pool
idKey, parentPoolName));
}
IdEntries existingIdEntry = existingIdEntryObject.get();
- List<Long> idValuesList = nonnull(existingIdEntry.getIdValue());
+ List<Uint32> idValuesList = nonnull(existingIdEntry.getIdValue());
IdLocalPool localIdPoolCache = localPool.get(parentPoolName);
- boolean isRemoved = idEntries.remove(existingIdEntry);
+ boolean isRemoved = idEntries.contains(existingIdEntry);
LOG.debug("The entry {} is removed {}", existingIdEntry, isRemoved);
updateDelayedEntriesInLocalCache(idValuesList, parentPoolName, localIdPoolCache);
IdHolderSyncJob poolSyncJob = new IdHolderSyncJob(localPoolName, localIdPoolCache.getReleasedIds(), txRunner,
idUtils);
jobCoordinator.enqueueJob(localPoolName, poolSyncJob, IdUtils.RETRY_COUNT);
- scheduleCleanUpTask(localIdPoolCache, parentPoolName, parentIdPool.getBlockSize());
+ scheduleCleanUpTask(localIdPoolCache, parentPoolName, parentIdPool.getBlockSize().toJava());
LOG.debug("Released id ({}, {}) from pool {}", idKey, idValuesList, localPoolName);
// Updating id entries in the parent pool. This will be used for restart scenario
UpdateIdEntryJob job = new UpdateIdEntryJob(parentPoolName, localPoolName, idKey, null, txRunner, idUtils,
String parentPool = idPool.getPoolName();
localPool.put(parentPool, idLocalPool);
LocalPoolCreateJob job = new LocalPoolCreateJob(idLocalPool, txRunner, idPool.getPoolName(),
- idPool.getBlockSize(), idUtils);
+ idPool.getBlockSize().toJava(), idUtils);
jobCoordinator.enqueueJob(localPoolName, job, IdUtils.RETRY_COUNT);
return idLocalPool;
}
}
}
- private void updateDelayedEntriesInLocalCache(List<Long> idsList, String parentPoolName,
+ private void updateDelayedEntriesInLocalCache(List<Uint32> idsList, String parentPoolName,
IdLocalPool localPoolCache) {
- for (long idValue : idsList) {
- localPoolCache.getReleasedIds().addId(idValue);
+ for (Uint32 idValue : idsList) {
+ localPoolCache.getReleasedIds().addId(idValue.toJava());
}
localPool.put(parentPoolName, localPoolCache);
}
- private List<Long> checkForIdInIdEntries(String parentPoolName, String idKey, String uniqueIdKey,
- CompletableFuture<List<Long>> futureIdValues, boolean hasExistingFutureIdValues)
+ private List<Uint32> checkForIdInIdEntries(String parentPoolName, String idKey, String uniqueIdKey,
+ CompletableFuture<List<Uint32>> futureIdValues, boolean hasExistingFutureIdValues)
throws IdManagerException, ReadFailedException {
InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier = idUtils.getIdPoolInstance(parentPoolName);
InstanceIdentifier<IdEntries> existingId = idUtils.getIdEntry(parentIdPoolInstanceIdentifier, idKey);
idUtils.lock(lockManager, uniqueIdKey);
- List<Long> newIdValuesList = new ArrayList<>();
+ List<Uint32> newIdValuesList = new ArrayList<>();
Optional<IdEntries> existingIdEntry =
singleTxDB.syncReadOptional(LogicalDatastoreType.CONFIGURATION, existingId);
if (existingIdEntry.isPresent()) {
return localIdPool;
}
- private void getRangeOfIds(String parentPoolName, String localPoolName, long size, List<Long> newIdValuesList,
+ private void getRangeOfIds(String parentPoolName, String localPoolName, long size, List<Uint32> newIdValuesList,
IdLocalPool localIdPool, long newIdValue) throws ReadFailedException, IdManagerException {
InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier1 = idUtils.getIdPoolInstance(parentPoolName);
IdPool parentIdPool = singleTxDB.syncRead(LogicalDatastoreType.CONFIGURATION, parentIdPoolInstanceIdentifier1);
+ localIdPool.getReleasedIds().getAvailableIdCount();
AvailableIdsHolderBuilder availableParentIds = idUtils.getAvailableIdsHolderBuilder(parentIdPool);
ReleasedIdsHolderBuilder releasedParentIds = IdUtils.getReleaseIdsHolderBuilder(parentIdPool);
- totalAvailableIdCount = totalAvailableIdCount + releasedParentIds.getAvailableIdCount()
+ totalAvailableIdCount = totalAvailableIdCount + releasedParentIds.getAvailableIdCount().toJava()
+ idUtils.getAvailableIdsCount(availableParentIds);
if (totalAvailableIdCount > size) {
while (size > 0) {
// available IDs.
updateDelayedEntriesInLocalCache(newIdValuesList, parentPoolName, localIdPool);
}
- newIdValuesList.add(newIdValue);
+ newIdValuesList.add(Uint32.valueOf(newIdValue));
size--;
}
} else {
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final int DEFAULT_BLOCK_SIZE_DIFF = 10;
public static final int RETRY_COUNT = 6;
- private final ConcurrentHashMap<String, CompletableFuture<List<Long>>> allocatedIdMap = new ConcurrentHashMap<>();
+ private final ConcurrentHashMap<String, CompletableFuture<List<Uint32>>> allocatedIdMap = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, CountDownLatch> releaseIdLatchMap = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, AtomicInteger> poolUpdatedMap = new ConcurrentHashMap<>();
bladeId = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
}
- public CompletableFuture<List<Long>> removeAllocatedIds(String uniqueIdKey) {
+ public CompletableFuture<List<Uint32>> removeAllocatedIds(String uniqueIdKey) {
return allocatedIdMap.remove(uniqueIdKey);
}
- public CompletableFuture<List<Long>> putAllocatedIdsIfAbsent(String uniqueIdKey,
- CompletableFuture<List<Long>> futureIdValues) {
+ public CompletableFuture<List<Uint32>> putAllocatedIdsIfAbsent(String uniqueIdKey,
+ CompletableFuture<List<Uint32>> futureIdValues) {
return allocatedIdMap.putIfAbsent(uniqueIdKey, futureIdValues);
}
return idEntriesBuilder.build();
}
- public IdEntries createIdEntries(String idKey, List<Long> newIdVals) {
+ public IdEntries createIdEntries(String idKey, List<Uint32> newIdVals) {
return new IdEntriesBuilder().withKey(new IdEntriesKey(idKey))
.setIdKey(idKey).setIdValue(newIdVals).build();
}
protected boolean isIdAvailable(AvailableIdsHolderBuilder availableIds) {
if (availableIds.getCursor() != null && availableIds.getEnd() != null) {
- return availableIds.getCursor() < availableIds.getEnd();
+ return availableIds.getCursor() < availableIds.getEnd().toJava();
}
return false;
}
.setReadyTimeSec(System.currentTimeMillis() / 1000).build();
existingDelayedIdEntriesInParent.add(delayedIdEntries);
}
- long availableIdCountParent = releasedIdsParent.getAvailableIdCount();
+ long availableIdCountParent = releasedIdsParent.getAvailableIdCount().toJava();
releasedIdsParent.setDelayedIdEntries(existingDelayedIdEntriesInParent)
.setAvailableIdCount(availableIdCountParent + idCountToBeFreed);
}
public long getAvailableIdsCount(AvailableIdsHolderBuilder availableIds) {
if (availableIds != null && isIdAvailable(availableIds)) {
- return availableIds.getEnd() - availableIds.getCursor();
+ return availableIds.getEnd().toJava() - availableIds.getCursor();
}
return 0;
}
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.ListenableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final String parentPoolName;
private final String localPoolName;
private final String idKey;
- private final List<Long> newIdValues = new ArrayList<>();
+ private final List<Uint32> newIdValues = new ArrayList<>();
private final ManagedNewTransactionRunner txRunner;
private final IdUtils idUtils;
private final LockManagerService lockManager;
public UpdateIdEntryJob(String parentPoolName, String localPoolName, String idKey,
- List<Long> newIdValues, ManagedNewTransactionRunner txRunner, IdUtils idUtils,
+ List<Uint32> newIdValues, ManagedNewTransactionRunner txRunner, IdUtils idUtils,
LockManagerService lockManager) {
this.parentPoolName = parentPoolName;
this.localPoolName = localPoolName;
return Collections.singletonList(future);
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void cleanUp() {
String uniqueIdKey = idUtils.getUniqueKey(parentPoolName, idKey);
CountDownLatch latch = idUtils.getReleaseIdLatch(uniqueIdKey);
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder
+import org.opendaylight.yangtools.yang.common.Uint32;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
new IdEntriesBuilder >> [
idKey = "test-key1"
idValue = #[
- 1L
+ Uint32.valueOf(1L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key2"
idValue = #[
- 0L
+ Uint32.valueOf(0L)
]
]
]
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder
+import org.opendaylight.yangtools.yang.common.Uint32;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
new IdEntriesBuilder >> [
idKey = "test-key10"
idValue = #[
- 1L
+ Uint32.valueOf(1L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key12"
idValue = #[
- 0L
+ Uint32.valueOf(0L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key11"
idValue = #[
- 2L
+ Uint32.valueOf(2L)
]
]
]
]
]
}
-}
\ No newline at end of file
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder
+import org.opendaylight.yangtools.yang.common.Uint32;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
new IdEntriesBuilder >> [
idKey = "test-key1"
idValue = #[
- 0L
+ Uint32.valueOf(0L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key12"
idValue = #[
- 3L
+ Uint32.valueOf(3L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key11"
idValue = #[
- 2L
+ Uint32.valueOf(2L)
]
],
new IdEntriesBuilder >> [
idKey = "test-key10"
idValue = #[
- 1L
+ Uint32.valueOf(1L)
]
]
]
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder
+import org.opendaylight.yangtools.yang.common.Uint32;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
new IdEntriesBuilder >> [
idKey = "test-key1"
idValue = #[
- 0L
+ Uint32.valueOf(0L)
]
]
]
]
]
}
-}
\ No newline at end of file
+}
new AllocateIdInputBuilder().setPoolName(ID_POOL_NAME).setIdKey(idKey).build());
try {
if (result.get().isSuccessful()) {
- Long idValue = result.get().getResult().getIdValue();
+ Long idValue = result.get().getResult().getIdValue().toJava();
idSet.add(idValue);
if (idValue > ID_LOW + BLOCK_SIZE) {
exceptionInExecutorAtomic.set(new AssertionFailedError("idValue <= ID_LOW + BLOCK_SIZE"));
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
*/
package org.opendaylight.genius.interfacemanager.globals;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class IfmConstants {
public static final int FLOW_TABLE_MISS_PRIORITY = 0;
public static final int DEFAULT_ARP_FLOW_PRIORITY = 100;
public static final int INVALID_PORT_NO = -1;
- public static final BigInteger INVALID_DPID = new BigInteger("-1");
// Id pool
public static final String IFM_IDPOOL_NAME = "interfaces";
// Table
public static final long DELAY_TIME_IN_MILLISECOND = 10000;
// Cookies
- public static final BigInteger COOKIE_L3_BASE = new BigInteger("8000000", 16);
- public static final BigInteger COOKIE_EGRESS_DISPATCHER_TABLE = new BigInteger("1300000", 16);
+ public static final Uint64 COOKIE_L3_BASE = Uint64.valueOf("8000000", 16).intern();
+ public static final Uint64 COOKIE_EGRESS_DISPATCHER_TABLE = Uint64.valueOf("1300000", 16).intern();
// Tunnel Monitoring
public static final int DEFAULT_MONITOR_INTERVAL = 10000;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.Serializable;
-import java.math.BigInteger;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class InterfaceInfo implements Serializable {
protected InterfaceType interfaceType;
protected int interfaceTag;
- protected BigInteger dpId = IfmConstants.INVALID_DPID;
+ protected Uint64 dpId;
protected InterfaceAdminState adminState = InterfaceAdminState.ENABLED;
protected InterfaceOpState opState;
protected long groupId;
protected boolean isUntaggedVlan;
protected String macAddress;
- public InterfaceInfo(BigInteger dpId, String portName) {
+ public InterfaceInfo(Uint64 dpId, String portName) {
this.dpId = dpId;
this.portName = portName;
}
return isUntaggedVlan;
}
- // "Confusing to have methods getDpId() and BridgeEntryBuilder.getDpid" - BridgeEntryBuilder is generated so can't
- // change it.
- @SuppressFBWarnings("NM_CONFUSING")
- public BigInteger getDpId() {
+ @SuppressFBWarnings(value = "NM_CONFUSING",
+ justification = "'Confusing to have methods getDpId() and BridgeEntryBuilder.getDpid'"
+ + " - BridgeEntryBuilder is generated so cannot change it.")
+ public @Nullable Uint64 getDpId() {
return dpId;
}
- public void setDpId(BigInteger dpId) {
+ public void setDpId(Uint64 dpId) {
this.dpId = dpId;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager.globals;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServicesKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class InterfaceServiceUtil {
*/
@Deprecated
public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, int servicePriority,
- BigInteger cookie, List<Instruction> instructions) {
+ Uint64 cookie, List<Instruction> instructions) {
return buildServiceInfo(serviceName, servicePriority);
}
*/
@Deprecated
public static ServicesInfo buildServiceInfo(String serviceName, short serviceIndex, int servicePriority,
- BigInteger cookie) {
+ Uint64 cookie) {
return buildServiceInfo(serviceName, servicePriority);
}
}
public static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
- BigInteger cookie, List<Instruction> instructions) {
+ Uint64 cookie, List<Instruction> instructions) {
StypeOpenflowBuilder augBuilder = new StypeOpenflowBuilder().setFlowCookie(cookie).setFlowPriority(flowPriority)
.setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority)).setServiceName(serviceName)
.addAugmentation(StypeOpenflow.class, augBuilder.build()).build();
}
- public static List<MatchInfo> getMatchInfoForVlanLPort(BigInteger dpId, long portNo, long vlanId,
+ public static List<MatchInfo> getMatchInfoForVlanLPort(Uint64 dpId, long portNo, long vlanId,
boolean isVlanTransparent) {
List<MatchInfo> matches = new ArrayList<>();
matches.add(new MatchInPort(dpId, portNo));
if (match2 instanceof MatchMetadata) {
if (match instanceof MatchMetadata) {
MatchMetadata metadataMatch = (MatchMetadata) match;
- BigInteger value = MetaDataUtil.mergeMetadataValues(((MatchMetadata) match2).getMetadata(),
+ Uint64 value = MetaDataUtil.mergeMetadataValues(((MatchMetadata) match2).getMetadata(),
metadataMatch.getMetadata());
- BigInteger mask = MetaDataUtil.mergeMetadataMask(((MatchMetadata) match2).getMask(),
+ Uint64 mask = MetaDataUtil.mergeMetadataMask(((MatchMetadata) match2).getMask(),
metadataMatch.getMask());
match = new MatchMetadata(value, mask);
iter.remove();
return -1;
}
- public static Set<Object> getStatRequestKeys(BigInteger dpId, short tableId, List<MatchInfo> matches, String flowId,
+ public static Set<Object> getStatRequestKeys(Uint64 dpId, short tableId, List<MatchInfo> matches, String flowId,
long groupId) {
Set<Object> statRequestKeys = new HashSet<>();
statRequestKeys.add(getFlowStatisticsKey(dpId, tableId, matches, flowId));
return statRequestKeys;
}
- public static GroupInfoKey getGroupStatisticsKey(BigInteger dpId, long groupId) {
+ public static GroupInfoKey getGroupStatisticsKey(Uint64 dpId, long groupId) {
return new GroupInfoKey(dpId, groupId);
}
- public static FlowInfoKey getFlowStatisticsKey(BigInteger dpId, short tableId, List<MatchInfo> matches,
+ public static FlowInfoKey getFlowStatisticsKey(Uint64 dpId, short tableId, List<MatchInfo> matches,
String flowId) {
return new FlowInfoKey(dpId, tableId, MDSALUtil.buildMatches(matches), flowId);
}
*/
package org.opendaylight.genius.interfacemanager.globals;
-import java.math.BigInteger;
import java.util.List;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class LogicalGroupInterfaceInfo extends InterfaceInfo {
private static final long serialVersionUID = 1L;
// interface between a pair of DPNs
private final List<String> parentInterfaceNames;
- public LogicalGroupInterfaceInfo(String portName, BigInteger srcDpId, List<String> parentInterfaces) {
+ public LogicalGroupInterfaceInfo(String portName, Uint64 srcDpId, List<String> parentInterfaces) {
super(srcDpId, portName);
this.parentInterfaceNames = parentInterfaces;
}
*/
package org.opendaylight.genius.interfacemanager.globals;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
+// FIXME: This class should follow builder pattern to support proper lifecycle
public class VlanInterfaceInfo extends InterfaceInfo {
-
private static final long serialVersionUID = 1L;
+
private short vlanId;
+
private boolean isVlanTransparent;
- public VlanInterfaceInfo(BigInteger dpId, String portName, short vlanId) {
+ public VlanInterfaceInfo(Uint64 dpId, String portName, short vlanId) {
super(dpId, portName);
this.vlanId = vlanId;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager.interfaces;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface IInterfaceManager {
Long getPortForInterface(Interface intf);
- BigInteger getDpnForInterface(String ifName);
+ Uint64 getDpnForInterface(String ifName);
- BigInteger getDpnForInterface(Interface intrf);
+ Uint64 getDpnForInterface(Interface intrf);
- String getEndpointIpForDpn(BigInteger dpnId);
+ String getEndpointIpForDpn(Uint64 dpnId);
List<ActionInfo> getInterfaceEgressActions(String ifName);
* @deprecated Use {@link #createVLANInterface(String, String, Integer, String, IfL2vlan.L2vlanMode)}.
*/
@Deprecated
- void createVLANInterface(String interfaceName, String portName, BigInteger dpId, Integer vlanId, String description,
+ void createVLANInterface(String interfaceName, String portName, Uint64 dpId, Integer vlanId, String description,
IfL2vlan.L2vlanMode l2vlanMode) throws InterfaceAlreadyExistsException;
ListenableFuture<Void> createVLANInterface(String interfaceName, String portName, Integer vlanId,
* @deprecated Use {@link #createVLANInterface(String, String, Integer, String, IfL2vlan.L2vlanMode, boolean)}.
*/
@Deprecated
- void createVLANInterface(String interfaceName, String portName, BigInteger dpId, Integer vlanId, String description,
+ void createVLANInterface(String interfaceName, String portName, Uint64 dpId, Integer vlanId, String description,
IfL2vlan.L2vlanMode l2vlanMode, boolean isExternal) throws InterfaceAlreadyExistsException;
ListenableFuture<Void> createVLANInterface(String interfaceName, String portName, Integer vlanId,
OvsdbBridgeAugmentation getOvsdbBridgeForNodeIid(InstanceIdentifier<Node> nodeIid);
- List<OvsdbTerminationPointAugmentation> getPortsOnBridge(BigInteger dpnId);
+ List<OvsdbTerminationPointAugmentation> getPortsOnBridge(Uint64 dpnId);
- List<OvsdbTerminationPointAugmentation> getTunnelPortsOnBridge(BigInteger dpnId);
+ List<OvsdbTerminationPointAugmentation> getTunnelPortsOnBridge(Uint64 dpnId);
Map<Class<? extends InterfaceTypeBase>, List<OvsdbTerminationPointAugmentation>>
- getPortsOnBridgeByType(BigInteger dpnId);
+ getPortsOnBridgeByType(Uint64 dpnId);
void updateInterfaceParentRef(String interfaceName, String parentInterface);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
+// FIXME: rename this to IfmImplConstants
+// FIXME: this should be a final utility class
public interface IfmConstants {
String IFM_IDPOOL_NAME = "interfaces";
long IFM_ID_POOL_START = 1L;
long VLAN_GROUP_START = 1000;
long TRUNK_GROUP_START = 20000;
long LOGICAL_GROUP_START = 100000;
- BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
+ Uint64 COOKIE_VM_LFIB_TABLE = Uint64.valueOf("8000002", 16).intern();
String TUNNEL_TABLE_FLOWID_PREFIX = "TUNNEL.";
- BigInteger TUNNEL_TABLE_COOKIE = new BigInteger("9000000", 16);
+ Uint64 TUNNEL_TABLE_COOKIE = Uint64.valueOf("9000000", 16).intern();
int FLOW_HIGH_PRIORITY = 10;
int FLOW_PRIORITY_FOR_UNTAGGED_VLAN = 4;
int JOB_MAX_RETRIES = 6;
long DELAY_TIME_IN_MILLISECOND = 10000;
- String DEAD_BEEF_MAC_PREFIX = "DEADBEEF";
+ Uint64 DEAD_BEEF_MAC_PREFIX = Uint64.valueOf("DEADBEEF", 16).intern();
String INVALID_MAC = "00:00:00:00:00:00";
String MAC_SEPARATOR = ":";
- Integer MAC_STRING_LENGTH = 17;
+ int MAC_STRING_LENGTH = INVALID_MAC.length();
long INVALID_PORT_NO = -1;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+import java.util.regex.Pattern;
import org.apache.commons.lang3.BooleanUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final class IfmUtil {
-
private static final Logger LOG = LoggerFactory.getLogger(IfmUtil.class);
+ private static final Pattern GENERATE_MAC_PATTERN = Pattern.compile("(.{2})");
private static final int INVALID_ID = 0;
private IfmUtil() {
.put(TunnelTypeLogicalGroup.class, LOGICAL_GROUP_INTERFACE)
.build();
- public static BigInteger getDpnFromNodeConnectorId(NodeConnectorId portId) {
- return new BigInteger(getDpnStringFromNodeConnectorId(portId));
+ public static Uint64 getDpnFromNodeConnectorId(NodeConnectorId portId) {
+ return Uint64.valueOf(getDpnStringFromNodeConnectorId(portId));
}
public static String getDpnStringFromNodeConnectorId(NodeConnectorId portId) {
return portId.getValue().split(IfmConstants.OF_URI_SEPARATOR)[1];
}
- public static BigInteger getDpnFromInterface(
+ public static Uint64 getDpnFromInterface(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface ifState) {
NodeConnectorId ncId = getNodeConnectorIdFromInterface(ifState);
return IfmConstants.INVALID_PORT_NO;
}
- public static NodeId buildDpnNodeId(BigInteger dpnId) {
+ public static NodeId buildDpnNodeId(Uint64 dpnId) {
return new NodeId(IfmConstants.OF_URI_PREFIX + dpnId);
}
case VXLAN_TRUNK_INTERFACE:
if (!isDefaultEgress) {
if (tunnelKey != null) {
- result.add(new ActionSetFieldTunnelId(actionKeyStart++, BigInteger.valueOf(tunnelKey)));
+ result.add(new ActionSetFieldTunnelId(actionKeyStart++, Uint64.valueOf(tunnelKey)));
}
} else {
// For OF Tunnels default egress actions need to set tunnelIps
boolean isVlanTransparent = false;
int vlanVid = 0;
if (vlanIface != null) {
- vlanVid = vlanIface.getVlanId() == null ? 0 : vlanIface.getVlanId().getValue();
+ vlanVid = vlanIface.getVlanId() == null ? 0 : vlanIface.getVlanId().getValue().toJava();
isVlanTransparent = vlanIface.getL2vlanMode() == IfL2vlan.L2vlanMode.Transparent;
}
if (vlanVid != 0 && !isVlanTransparent) {
return new NodeId(ncId.getValue().substring(0, ncId.getValue().lastIndexOf(':')));
}
- public static BigInteger[] mergeOpenflowMetadataWriteInstructions(List<Instruction> instructions) {
- BigInteger metadata = new BigInteger("0", 16);
- BigInteger metadataMask = new BigInteger("0", 16);
+ public static Uint64[] mergeOpenflowMetadataWriteInstructions(List<Instruction> instructions) {
+ Uint64 metadata = Uint64.ZERO;
+ Uint64 metadataMask = Uint64.ZERO;
if (instructions != null && !instructions.isEmpty()) {
// check if metadata write instruction is present
for (Instruction instruction : instructions) {
if (actualInstruction instanceof WriteMetadataCase) {
WriteMetadataCase writeMetaDataInstruction = (WriteMetadataCase) actualInstruction;
WriteMetadata availableMetaData = writeMetaDataInstruction.getWriteMetadata();
- metadata = metadata.or(availableMetaData.getMetadata());
- metadataMask = metadataMask.or(availableMetaData.getMetadataMask());
+ metadata = Uint64.fromLongBits(metadata.longValue() | availableMetaData.getMetadata().longValue());
+ metadataMask = Uint64.fromLongBits(metadataMask.longValue()
+ | availableMetaData.getMetadataMask().longValue());
}
}
}
- return new BigInteger[] { metadata, metadataMask };
+ return new Uint64[] { metadata, metadataMask };
}
public static Integer allocateId(IdManagerService idManager, String poolName, String idKey) {
}
}
- public static BigInteger getDpnId(DatapathId datapathId) {
+ public static Uint64 getDpnId(DatapathId datapathId) {
if (datapathId != null) {
// Adding logs for a random issue spotted during datapath id
// conversion
String dpIdStr = datapathId.getValue().replace(":", "");
- return new BigInteger(dpIdStr, 16);
+ return Uint64.valueOf(dpIdStr, 16);
}
return null;
}
return interfaceType;
}
- public static VlanInterfaceInfo getVlanInterfaceInfo(Interface iface, BigInteger dpId) {
+ public static VlanInterfaceInfo getVlanInterfaceInfo(Interface iface, Uint64 dpId) {
short vlanId = 0;
String portName = null;
IfL2vlan vlanIface = iface.augmentation(IfL2vlan.class);
return vlanInterfaceInfo;
}
- public static BigInteger getDeadBeefBytesForMac() {
- return new BigInteger("FFFFFFFF", 16).and(new BigInteger(IfmConstants.DEAD_BEEF_MAC_PREFIX, 16)).shiftLeft(16);
+ public static Uint64 getDeadBeefBytesForMac() {
+ final long raw = IfmConstants.DEAD_BEEF_MAC_PREFIX.longValue() & 0xFFFFFFFFL;
+ return Uint64.fromLongBits(raw << 16);
}
- public static BigInteger fillPortNumberToMac(long portNumber) {
- return new BigInteger("FFFF", 16).and(BigInteger.valueOf(portNumber));
+ public static Uint64 fillPortNumberToMac(long portNumber) {
+ return Uint64.fromLongBits(portNumber & 0xFFFF);
}
public static String generateMacAddress(long portNo) {
- String unformattedMAC = getDeadBeefBytesForMac().or(fillPortNumberToMac(portNo)).toString(16);
- return unformattedMAC.replaceAll("(.{2})", "$1" + IfmConstants.MAC_SEPARATOR).substring(0,
- IfmConstants.MAC_STRING_LENGTH);
+ final long raw = getDeadBeefBytesForMac().longValue() | fillPortNumberToMac(portNo).longValue();
+ return GENERATE_MAC_PATTERN.matcher(Long.toUnsignedString(raw))
+ .replaceAll("$1" + IfmConstants.MAC_SEPARATOR)
+ .substring(0, IfmConstants.MAC_STRING_LENGTH);
}
public static PhysAddress getPhyAddress(long portNo, FlowCapableNodeConnector flowCapableNodeConnector) {
BoundServices serviceInfo, Class<? extends ServiceModeBase> serviceMode) {
LOG.info("Binding Service {} for : {}", serviceInfo.getServiceName(), interfaceName);
InstanceIdentifier<BoundServices> boundServicesInstanceIdentifier = buildBoundServicesIId(
- serviceInfo.getServicePriority(), interfaceName, serviceMode);
+ serviceInfo.getServicePriority().toJava(), interfaceName, serviceMode);
tx.put(boundServicesInstanceIdentifier, serviceInfo, CREATE_MISSING_PARENTS);
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
try {
RpcResult<GetPortFromInterfaceOutput> port = output.get();
if (port.isSuccessful()) {
- return port.getResult().getPortno();
+ return port.getResult().getPortno().toJava();
}
} catch (NullPointerException | InterruptedException | ExecutionException e) {
LOG.warn("Exception when getting port for interface", e);
try {
RpcResult<GetPortFromInterfaceOutput> port = output.get();
if (port.isSuccessful()) {
- return port.getResult().getPortno();
+ return port.getResult().getPortno().toJava();
}
} catch (NullPointerException | InterruptedException | ExecutionException e) {
LOG.warn("Exception when getting port for interface", e);
interfaceManagerCommonUtils);
InterfaceInfo.InterfaceType interfaceType = IfmUtil.getInterfaceType(intf);
InterfaceInfo interfaceInfo = new InterfaceInfo(interfaceName);
- BigInteger dpId = org.opendaylight.genius.interfacemanager.globals.IfmConstants.INVALID_DPID;
Integer portNo = org.opendaylight.genius.interfacemanager.globals.IfmConstants.INVALID_PORT_NO;
+ final Uint64 dpId;
if (ncId != null) {
dpId = IfmUtil.getDpnFromNodeConnectorId(ncId);
portNo = Integer.parseInt(IfmUtil.getPortNoFromNodeConnectorId(ncId));
+ } else {
+ dpId = null;
}
if (interfaceType == InterfaceInfo.InterfaceType.VLAN_INTERFACE) {
interfaceInfo = IfmUtil.getVlanInterfaceInfo(intf, dpId);
}
@Override
- public void createVLANInterface(String interfaceName, String portName, BigInteger dpId, Integer vlanId,
+ public void createVLANInterface(String interfaceName, String portName, Uint64 dpId, Integer vlanId,
String description, IfL2vlan.L2vlanMode l2vlanMode) throws InterfaceAlreadyExistsException {
createVLANInterface(interfaceName, portName, vlanId, description, l2vlanMode);
}
}
@Override
- public void createVLANInterface(String interfaceName, String portName, BigInteger dpId, Integer vlanId,
+ public void createVLANInterface(String interfaceName, String portName, Uint64 dpId, Integer vlanId,
String description, IfL2vlan.L2vlanMode l2vlanMode, boolean isExternal)
throws InterfaceAlreadyExistsException {
createVLANInterface(interfaceName, portName, vlanId, description, l2vlanMode, isExternal);
if (isExternal) {
interfaceBuilder.addAugmentation(IfExternal.class, new IfExternalBuilder().setExternal(true).build());
}
- InstanceIdentifier<Interface> interfaceIId = interfaceManagerCommonUtils
+ InstanceIdentifier<Interface> interfaceIId = InterfaceManagerCommonUtils
.getInterfaceIdentifier(new InterfaceKey(interfaceName));
ListenableFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> tx.put(interfaceIId, interfaceBuilder.build(), CREATE_MISSING_PARENTS));
public void unbindService(String interfaceName, Class<? extends ServiceModeBase> serviceMode,
BoundServices serviceInfo) {
IfmUtil.unbindService(txRunner, coordinator, interfaceName,
- FlowBasedServicesUtils.buildServiceId(interfaceName, serviceInfo.getServicePriority(), serviceMode));
+ FlowBasedServicesUtils.buildServiceId(interfaceName,
+ serviceInfo.getServicePriority().toJava(), serviceMode));
}
@Override
- public BigInteger getDpnForInterface(Interface intrf) {
+ public Uint64 getDpnForInterface(Interface intrf) {
return getDpnForInterface(intrf.getName());
}
@Override
- public BigInteger getDpnForInterface(String ifName) {
+ public Uint64 getDpnForInterface(String ifName) {
GetDpidFromInterfaceInput input = new GetDpidFromInterfaceInputBuilder().setIntfName(ifName).build();
Future<RpcResult<GetDpidFromInterfaceOutput>> output = interfaceManagerRpcService.getDpidFromInterface(input);
try {
}
@Override
- public String getEndpointIpForDpn(BigInteger dpnId) {
+ public String getEndpointIpForDpn(Uint64 dpnId) {
GetEndpointIpForDpnInput input = new GetEndpointIpForDpnInputBuilder().setDpid(dpnId).build();
Future<RpcResult<GetEndpointIpForDpnOutput>> output = interfaceManagerRpcService.getEndpointIpForDpn(input);
try {
public String getDpidForInterface(String interfaceName, InstanceIdentifier<Node> nodeInstanceId) {
OvsdbBridgeAugmentation bridge = getBridgeForInterface(interfaceName, nodeInstanceId);
if (bridge != null) {
- BigInteger dpid = IfmUtil.getDpnId(bridge.getDatapathId());
+ Uint64 dpid = IfmUtil.getDpnId(bridge.getDatapathId());
if (dpid != null && dpid.longValue() != 0) {
return String.valueOf(dpid);
}
* @return If the data at the supplied path exists, returns a list of all termination point
* Augmentations
*/
- public List<OvsdbTerminationPointAugmentation> getPortsOnBridge(BigInteger dpnId) {
+ public List<OvsdbTerminationPointAugmentation> getPortsOnBridge(Uint64 dpnId) {
List<OvsdbTerminationPointAugmentation> ports = new ArrayList<>();
List<TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
for (TerminationPoint ovsPort : portList) {
* Augmentations of type tunnel
*/
@Override
- public List<OvsdbTerminationPointAugmentation> getTunnelPortsOnBridge(BigInteger dpnId) {
+ public List<OvsdbTerminationPointAugmentation> getTunnelPortsOnBridge(Uint64 dpnId) {
List<OvsdbTerminationPointAugmentation> tunnelPorts = new ArrayList<>();
List<TerminationPoint> portList = interfaceMetaUtils.getTerminationPointsOnBridge(dpnId);
for (TerminationPoint ovsPort : portList) {
*/
@Override
public Map<Class<? extends InterfaceTypeBase>, List<OvsdbTerminationPointAugmentation>>
- getPortsOnBridgeByType(BigInteger dpnId) {
+ getPortsOnBridgeByType(Uint64 dpnId) {
Map<Class<? extends InterfaceTypeBase>, List<OvsdbTerminationPointAugmentation>> portMap;
portMap = new ConcurrentHashMap<>();
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeLldp;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.build())
.setMode(MonitoringMode.OneOne)
.setProfileId(allocateProfile(FAILURE_THRESHOLD,
- ifTunnel.getMonitorInterval(), MONITORING_WINDOW, MonitorProtocolType.Lldp))
+ ifTunnel.getMonitorInterval().toJava(), MONITORING_WINDOW,
+ MonitorProtocolType.Lldp))
.build())
.build();
try {
Future<RpcResult<MonitorStartOutput>> result = alivenessMonitorService.monitorStart(lldpMonitorInput);
RpcResult<MonitorStartOutput> rpcResult = result.get();
if (rpcResult.isSuccessful()) {
- long monitorId = rpcResult.getResult().getMonitorId();
+ long monitorId = rpcResult.getResult().getMonitorId().toJava();
ListenableFutures.addErrorLogging(
txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, tx -> {
createOrUpdateInterfaceMonitorIdMap(tx, trunkInterfaceName, monitorId);
}
LOG.debug("stop LLDP monitoring for {}", trunkInterface);
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, tx -> {
- List<Long> monitorIds = getMonitorIdForInterface(tx, trunkInterface);
+ List<Uint32> monitorIds = getMonitorIdForInterface(tx, trunkInterface);
if (monitorIds == null) {
LOG.error("Monitor Id doesn't exist for Interface {}", trunkInterface);
return;
}
- for (Long monitorId : monitorIds) {
+ for (Uint32 monitorId : monitorIds) {
String interfaceName = getInterfaceFromMonitorId(tx, monitorId);
if (interfaceName != null) {
MonitorStopInput input = new MonitorStopInputBuilder().setMonitorId(monitorId).build();
}), LOG, "Error stopping LLDP monitoring for {}", trunkInterface);
}
- public static String getInterfaceFromMonitorId(TypedReadTransaction<Operational> tx, Long monitorId)
+ public static String getInterfaceFromMonitorId(TypedReadTransaction<Operational> tx, Uint32 monitorId)
throws ExecutionException, InterruptedException {
InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class)
.child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
return tx.read(id).get().toJavaUtil().map(MonitorIdInterface::getInterfaceName).orElse(null);
}
- private void removeMonitorIdInterfaceMap(TypedReadWriteTransaction<Operational> tx, long monitorId)
+ private void removeMonitorIdInterfaceMap(TypedReadWriteTransaction<Operational> tx, Uint32 monitorId)
throws ExecutionException, InterruptedException {
InstanceIdentifier<MonitorIdInterface> id = InstanceIdentifier.builder(MonitorIdInterfaceMap.class)
.child(MonitorIdInterface.class, new MonitorIdInterfaceKey(monitorId)).build();
}
private void removeMonitorIdFromInterfaceMonitorIdMap(TypedReadWriteTransaction<Operational> tx, String infName,
- long monitorId) throws ExecutionException, InterruptedException {
+ Uint32 monitorId) throws ExecutionException, InterruptedException {
InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class)
.child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
Optional<InterfaceMonitorId> interfaceMonitorIdMap = tx.read(id).get();
if (interfaceMonitorIdMap.isPresent()) {
InterfaceMonitorId interfaceMonitorIdInstance = interfaceMonitorIdMap.get();
- List<Long> existingMonitorIds = interfaceMonitorIdInstance.getMonitorId();
+ List<Uint32> existingMonitorIds = interfaceMonitorIdInstance.getMonitorId();
if (existingMonitorIds != null && existingMonitorIds.contains(monitorId)) {
existingMonitorIds.remove(monitorId);
InterfaceMonitorIdBuilder interfaceMonitorIdBuilder = new InterfaceMonitorIdBuilder();
IfTunnel ifTunnelOld = interfaceOld.augmentation(IfTunnel.class);
if (!Objects.equals(ifTunnelNew.getMonitorInterval(), ifTunnelOld.getMonitorInterval())) {
LOG.debug("deleting older monitor profile for interface {}", interfaceName);
- long profileId = allocateProfile(FAILURE_THRESHOLD, ifTunnelOld.getMonitorInterval(), MONITORING_WINDOW,
- MonitorProtocolType.Lldp);
+ Uint32 profileId = allocateProfile(FAILURE_THRESHOLD, ifTunnelOld.getMonitorInterval().toJava(),
+ MONITORING_WINDOW, MonitorProtocolType.Lldp);
MonitorProfileDeleteInput profileDeleteInput = new MonitorProfileDeleteInputBuilder()
.setProfileId(profileId).build();
private static void createOrUpdateInterfaceMonitorIdMap(TypedReadWriteTransaction<Operational> tx, String infName,
long monitorId) throws ExecutionException, InterruptedException {
InterfaceMonitorId interfaceMonitorIdInstance;
- List<Long> existingMonitorIds;
+ List<Uint32> existingMonitorIds;
InterfaceMonitorIdBuilder interfaceMonitorIdBuilder = new InterfaceMonitorIdBuilder();
InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class)
.child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
if (existingMonitorIds == null) {
existingMonitorIds = new ArrayList<>();
}
- if (!existingMonitorIds.contains(monitorId)) {
- existingMonitorIds.add(monitorId);
+ if (!existingMonitorIds.contains(Uint32.valueOf(monitorId))) {
+ existingMonitorIds.add(Uint32.valueOf(monitorId));
interfaceMonitorIdInstance = interfaceMonitorIdBuilder.withKey(new InterfaceMonitorIdKey(infName))
.setMonitorId(existingMonitorIds).build();
tx.merge(id, interfaceMonitorIdInstance, CREATE_MISSING_PARENTS);
}
} else {
existingMonitorIds = new ArrayList<>();
- existingMonitorIds.add(monitorId);
+ existingMonitorIds.add(Uint32.valueOf(monitorId));
interfaceMonitorIdInstance = interfaceMonitorIdBuilder.setMonitorId(existingMonitorIds)
.withKey(new InterfaceMonitorIdKey(infName)).setInterfaceName(infName).build();
tx.merge(id, interfaceMonitorIdInstance, CREATE_MISSING_PARENTS);
}
}
- private static List<Long> getMonitorIdForInterface(TypedReadTransaction<Operational> tx, String infName)
+ private static List<Uint32> getMonitorIdForInterface(TypedReadTransaction<Operational> tx, String infName)
throws ExecutionException, InterruptedException {
InstanceIdentifier<InterfaceMonitorId> id = InstanceIdentifier.builder(InterfaceMonitorIdMap.class)
.child(InterfaceMonitorId.class, new InterfaceMonitorIdKey(infName)).build();
return tx.read(id).get().toJavaUtil().map(InterfaceMonitorId::getMonitorId).orElse(null);
}
- public long createMonitorProfile(MonitorProfileCreateInput monitorProfileCreateInput) {
+ public Uint32 createMonitorProfile(MonitorProfileCreateInput monitorProfileCreateInput) {
try {
Future<RpcResult<MonitorProfileCreateOutput>> result = alivenessMonitorService
.monitorProfileCreate(monitorProfileCreateInput);
rpcResult.getErrors());
Profile createProfile = monitorProfileCreateInput.getProfile();
Future<RpcResult<MonitorProfileGetOutput>> existingProfile = alivenessMonitorService.monitorProfileGet(
- buildMonitorGetProfile(createProfile.getMonitorInterval(), createProfile.getMonitorWindow(),
- createProfile.getFailureThreshold(), createProfile.getProtocolType()));
+ buildMonitorGetProfile(createProfile.getMonitorInterval().toJava(),
+ createProfile.getMonitorWindow().toJava(),
+ createProfile.getFailureThreshold().toJava(), createProfile.getProtocolType()));
RpcResult<MonitorProfileGetOutput> rpcGetResult = existingProfile.get();
if (rpcGetResult.isSuccessful()) {
return rpcGetResult.getResult().getProfileId();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Exception when allocating profile Id", e);
}
- return 0;
+ return Uint32.valueOf(0);
}
private static MonitorProfileGetInput buildMonitorGetProfile(long monitorInterval, long monitorWindow,
return buildGetProfile.build();
}
- public long allocateProfile(long failureThreshold, long monitoringInterval, long monitoringWindow,
+ public Uint32 allocateProfile(long failureThreshold, long monitoringInterval, long monitoringWindow,
MonitorProtocolType protoType) {
MonitorProfileCreateInput input = new MonitorProfileCreateInputBuilder().setProfile(
new ProfileBuilder().setFailureThreshold(failureThreshold).setMonitorInterval(monitoringInterval)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager.commons;
import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return IfmUtil.read(LogicalDatastoreType.OPERATIONAL, ifStateId, dataBroker).orNull();
}
- public void addTunnelIngressFlow(TypedWriteTransaction<Configuration> tx, IfTunnel tunnel, BigInteger dpnId,
+ public void addTunnelIngressFlow(TypedWriteTransaction<Configuration> tx, IfTunnel tunnel, Uint64 dpnId,
long portNo, String interfaceName, int ifIndex) {
if (isTunnelWithoutIngressFlow(tunnel)) {
return;
List<InstructionInfo> mkInstructions = new ArrayList<>();
mkInstructions.add(
- new InstructionWriteMetadata(MetaDataUtil.getLportTagMetaData(ifIndex).or(BigInteger.ONE),
+ new InstructionWriteMetadata(
+ Uint64.fromLongBits(MetaDataUtil.getLportTagMetaData(ifIndex).longValue() | 1L),
MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG));
short tableId = tunnel.getTunnelInterfaceType().isAssignableFrom(TunnelTypeMplsOverGre.class)
? NwConstants.L3_LFIB_TABLE
mdsalApiManager.addFlow(tx, buildTunnelIngressFlowEntity(dpnId, interfaceName, matches, mkInstructions));
}
- public void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> tx, IfTunnel tunnel, BigInteger dpnId,
+ public void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> tx, IfTunnel tunnel, Uint64 dpnId,
String interfaceName) throws ExecutionException, InterruptedException {
if (isTunnelWithoutIngressFlow(tunnel)) {
return;
}
@NonNull
- private static FlowEntity buildTunnelIngressFlowEntity(BigInteger dpnId, String interfaceName,
+ private static FlowEntity buildTunnelIngressFlowEntity(Uint64 dpnId, String interfaceName,
List<MatchInfoBase> matches, List<InstructionInfo> mkInstructions) {
String flowRef = InterfaceManagerCommonUtils.getTunnelInterfaceFlowRef(dpnId,
NwConstants.VLAN_INTERFACE_INGRESS_TABLE, interfaceName);
mkInstructions);
}
- public static String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) {
+ public static String getTunnelInterfaceFlowRef(Uint64 dpnId, short tableId, String ifName) {
return String.valueOf(dpnId) + tableId + ifName;
}
tx.put(ifStateId, ifaceBuilder.build(), CREATE_MISSING_PARENTS);
// install ingress flow
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
long portNo = IfmUtil.getPortNumberFromNodeConnectorId(nodeConnectorId);
if (interfaceInfo != null && interfaceInfo.isEnabled() && ifState
.getOperStatus() == org.opendaylight.yang.gen.v1.urn
//logical tunnel group doesn't have OF port
ParentRefs parentRefs = interfaceInfo.augmentation(ParentRefs.class);
if (parentRefs != null) {
- BigInteger dpId = parentRefs.getDatapathNodeIdentifier();
+ Uint64 dpId = parentRefs.getDatapathNodeIdentifier();
String lowref = MDSALUtil.NODE_PREFIX + MDSALUtil.SEPARATOR + dpId + MDSALUtil.SEPARATOR + 0;
childLowerLayerIfList.add(0, lowref);
}
tx.put(ifStateId, ifState, CREATE_MISSING_PARENTS);
}
if (nodeConnectorId != null) {
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
// Update the DpnToInterfaceList OpDS
createOrUpdateDpnToInterface(dpId, interfaceName, interfaceType);
}
return matcher.matches();
}
- public void createOrUpdateDpnToInterface(BigInteger dpId, String infName,
+ public void createOrUpdateDpnToInterface(Uint64 dpId, String infName,
Class<? extends InterfaceType> interfaceType) {
DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpId);
InterfaceNameEntryKey interfaceNameEntryKey = new InterfaceNameEntryKey(infName);
batchingUtils.write(intfid, entryBuilder.build(), BatchingUtils.EntityType.DEFAULT_OPERATIONAL);
}
- public List<InterfaceNameEntry> getAllInterfaces(BigInteger dpnId) {
+ public List<InterfaceNameEntry> getAllInterfaces(Uint64 dpnId) {
DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpnId);
InstanceIdentifier<DpnToInterface> dpninterfaceListId =
InstanceIdentifier.builder(DpnToInterfaceList.class).child(DpnToInterface.class, dpnToInterfaceKey).build();
return null;
}
- public static void deleteDpnToInterface(BigInteger dpId, String infName, TypedReadWriteTransaction<Operational> tx)
- throws ExecutionException, InterruptedException {
+ public static void deleteDpnToInterface(Uint64 dpId, String infName, TypedReadWriteTransaction<Operational> tx)
+ throws ExecutionException, InterruptedException {
DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpId);
InstanceIdentifier<DpnToInterface> dpnToInterfaceId = InstanceIdentifier.builder(DpnToInterfaceList.class)
.child(DpnToInterface.class, dpnToInterfaceKey).build();
import static org.opendaylight.controller.md.sal.binding.api.WriteTransaction.CREATE_MISSING_PARENTS;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final DataBroker dataBroker;
private final IdManagerService idManager;
private final BatchingUtils batchingUtils;
- private final ConcurrentMap<BigInteger, BridgeEntry> bridgeEntryMap = new ConcurrentHashMap<>();
- private final ConcurrentMap<BigInteger, BridgeRefEntry> bridgeRefEntryMap = new ConcurrentHashMap<>();
+ private final ConcurrentMap<Uint64, BridgeEntry> bridgeEntryMap = new ConcurrentHashMap<>();
+ private final ConcurrentMap<Uint64, BridgeRefEntry> bridgeRefEntryMap = new ConcurrentHashMap<>();
@Inject
public InterfaceMetaUtils(@Reference DataBroker dataBroker,
return bridgeRefEntryInstanceIdentifierBuilder.build();
}
- public BridgeRefEntry getBridgeRefEntryFromOperationalDS(BigInteger dpId) {
+ public BridgeRefEntry getBridgeRefEntryFromOperationalDS(Uint64 dpId) {
BridgeRefEntryKey bridgeRefEntryKey = new BridgeRefEntryKey(dpId);
InstanceIdentifier<BridgeRefEntry> bridgeRefEntryIid = InterfaceMetaUtils
.getBridgeRefEntryIdentifier(bridgeRefEntryKey);
return bridgeRefEntry;
}
- public BridgeRefEntry getBridgeRefEntryFromOperDS(BigInteger dpId) {
+ public BridgeRefEntry getBridgeRefEntryFromOperDS(Uint64 dpId) {
BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromCache(dpId);
if (bridgeRefEntry != null) {
return bridgeRefEntry;
return bridgeRefEntry;
}
- public OvsdbBridgeRef getOvsdbBridgeRef(BigInteger dpId) {
+ public OvsdbBridgeRef getOvsdbBridgeRef(Uint64 dpId) {
BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpId);
public BridgeRefEntry getBridgeReferenceForInterface(Interface interfaceInfo) {
ParentRefs parentRefs = interfaceInfo.augmentation(ParentRefs.class);
- BigInteger dpn = parentRefs.getDatapathNodeIdentifier();
+ Uint64 dpn = parentRefs.getDatapathNodeIdentifier();
return getBridgeRefEntryFromOperDS(dpn);
}
return bridgeEntryIdBuilder.build();
}
- public BridgeEntry getBridgeEntryFromConfigDS(BigInteger dpnId) {
+ public BridgeEntry getBridgeEntryFromConfigDS(Uint64 dpnId) {
BridgeEntry bridgeEntry = getBridgeEntryFromCache(dpnId);
if (bridgeEntry != null) {
return bridgeEntry;
}
public BridgeEntry getBridgeEntryFromConfigDS(InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier) {
- BigInteger dpnId = bridgeEntryInstanceIdentifier.firstKeyOf(BridgeEntry.class).getDpid();
+ Uint64 dpnId = bridgeEntryInstanceIdentifier.firstKeyOf(BridgeEntry.class).getDpid();
return getBridgeEntryFromConfigDS(dpnId);
}
}
- public void createBridgeInterfaceEntryInConfigDS(BigInteger dpId, String childInterface) {
+ public void createBridgeInterfaceEntryInConfigDS(Uint64 dpId, String childInterface) {
BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
BridgeInterfaceEntryKey bridgeInterfaceEntryKey = new BridgeInterfaceEntryKey(childInterface);
InstanceIdentifier<BridgeInterfaceEntry> bridgeInterfaceEntryIid =
return ifIndex;
}
- public static void addBridgeRefToBridgeInterfaceEntry(BigInteger dpId, OvsdbBridgeRef ovsdbBridgeRef,
+ public static void addBridgeRefToBridgeInterfaceEntry(Uint64 dpId, OvsdbBridgeRef ovsdbBridgeRef,
TypedWriteTransaction<Configuration> tx) {
BridgeEntryKey bridgeEntryKey = new BridgeEntryKey(dpId);
InstanceIdentifier<BridgeEntry> bridgeEntryInstanceIdentifier = getBridgeEntryIdentifier(bridgeEntryKey);
tx.merge(bridgeEntryInstanceIdentifier, bridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
}
- public static void createBridgeRefEntry(BigInteger dpnId, InstanceIdentifier<?> bridgeIid,
+ public static void createBridgeRefEntry(Uint64 dpnId, InstanceIdentifier<?> bridgeIid,
TypedWriteTransaction<Operational> tx) {
LOG.debug("Creating bridge ref entry for dpn: {} bridge: {}",
dpnId, bridgeIid);
tx.put(bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), CREATE_MISSING_PARENTS);
}
- public static void deleteBridgeRefEntry(BigInteger dpnId, TypedWriteTransaction<Operational> tx) {
+ public static void deleteBridgeRefEntry(Uint64 dpnId, TypedWriteTransaction<Operational> tx) {
LOG.debug("Deleting bridge ref entry for dpn: {}", dpnId);
tx.delete(InterfaceMetaUtils.getBridgeRefEntryIdentifier(new BridgeRefEntryKey(dpnId)));
}
}
}
- public List<TerminationPoint> getTerminationPointsOnBridge(BigInteger dpnId) {
+ public List<TerminationPoint> getTerminationPointsOnBridge(Uint64 dpnId) {
BridgeRefEntry bridgeRefEntry = getBridgeRefEntryFromOperDS(dpnId);
if (bridgeRefEntry == null || bridgeRefEntry.getBridgeReference() == null) {
LOG.debug("BridgeRefEntry for DPNID {} not found", dpnId);
// Cache Util methods
// Start: BridgeEntryCache
- public void addBridgeEntryToCache(BigInteger dpnId, BridgeEntry bridgeEntry) {
+ public void addBridgeEntryToCache(Uint64 dpnId, BridgeEntry bridgeEntry) {
bridgeEntryMap.put(dpnId, bridgeEntry);
}
addBridgeEntryToCache(bridgeEntry.key().getDpid(), bridgeEntry);
}
- public void removeFromBridgeEntryCache(BigInteger dpnId) {
+ public void removeFromBridgeEntryCache(Uint64 dpnId) {
bridgeEntryMap.remove(dpnId);
}
removeFromBridgeEntryCache(bridgeEntry.key().getDpid());
}
- public BridgeEntry getBridgeEntryFromCache(BigInteger dpnId) {
+ public BridgeEntry getBridgeEntryFromCache(Uint64 dpnId) {
return bridgeEntryMap.get(dpnId);
}
// End: Bridge Entry Cache
//Start: BridgeRefEntry Cache
- public void addBridgeRefEntryToCache(BigInteger dpnId, BridgeRefEntry bridgeRefEntry) {
+ public void addBridgeRefEntryToCache(Uint64 dpnId, BridgeRefEntry bridgeRefEntry) {
bridgeRefEntryMap.put(dpnId, bridgeRefEntry);
}
addBridgeRefEntryToCache(bridgeRefEntry.key().getDpid(), bridgeRefEntry);
}
- public void removeFromBridgeRefEntryCache(BigInteger dpnId) {
+ public void removeFromBridgeRefEntryCache(Uint64 dpnId) {
bridgeRefEntryMap.remove(dpnId);
}
removeFromBridgeRefEntryCache(bridgeRefEntry.key().getDpid());
}
- public BridgeRefEntry getBridgeRefEntryFromCache(BigInteger dpnId) {
+ public BridgeRefEntry getBridgeRefEntryFromCache(Uint64 dpnId) {
return bridgeRefEntryMap.get(dpnId);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.LivenessState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.MonitorEvent;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void onMonitorEvent(MonitorEvent notification) {
ListenableFutures.addErrorLogging(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, tx -> {
- Long monitorId = notification.getEventData().getMonitorId();
+ Uint32 monitorId = notification.getEventData().getMonitorId();
String tunnelInterface = AlivenessMonitorUtils.getInterfaceFromMonitorId(tx, monitorId);
if (tunnelInterface == null) {
LOG.debug("Either monitoring for interface not started by Interfacemgr or it is not LLDP monitoring");
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
-import com.google.common.base.Function;
import com.google.common.util.concurrent.ListenableFuture;
-
import com.google.common.util.concurrent.MoreExecutors;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
nodeConnectorIdOld = new NodeConnectorId(ofportIds.get(0));
}
if (nodeConnectorIdOld != null && !nodeConnectorId.equals(nodeConnectorIdOld)) {
- BigInteger dpnIdOld = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorIdOld);
- BigInteger dpnIdNew = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpnIdOld = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorIdOld);
+ Uint64 dpnIdNew = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
if (!Objects.equals(dpnIdOld, dpnIdNew)) {
- if ((fcNodeConnectorNew.getReason() != PortReason.Add)
- && (interfaceState.getOperStatus()
- != Interface.OperStatus.Unknown)) {
+ if (fcNodeConnectorNew.getReason() != PortReason.Add
+ && interfaceState.getOperStatus()
+ != Interface.OperStatus.Unknown) {
LOG.error("Dropping Port update event for {}, as DPN id is changed from {} to {}",
fcNodeConnectorNew.getName(), dpnIdOld, dpnIdNew);
return;
NodeConnectorId nodeConnectorId = nodeConnectorIdOld != null
&& !nodeConnectorIdNew.equals(nodeConnectorIdOld) ? nodeConnectorIdOld : nodeConnectorIdNew;
// delete the port entry from interface operational DS
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
futures.add(txRunner.applyWithNewTransactionChainAndClose(txChain ->
txChain.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL, operTx -> {
InterfaceManagerCommonUtils.deleteDpnToInterface(dpId, interfaceName, operTx);
}
return Optional.empty();
- }).transform(new Function<Optional<?>, Void>() {
- @Nullable
- @Override
- public Void apply(@Nullable Optional<?> optionalJob) {
- if (optionalJob != null && optionalJob.isPresent()) {
- txChain.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
- (InterruptibleCheckedConsumer<TypedReadWriteTransaction<Configuration>, ?
- extends Exception>) optionalJob.get());
- }
- return null;
+ }).transform((@Nullable Optional<?> optionalJob) -> {
+ if (optionalJob != null && optionalJob.isPresent()) {
+ txChain.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION,
+ (InterruptibleCheckedConsumer<TypedReadWriteTransaction<Configuration>, ?
+ extends Exception>) optionalJob.get());
}
+ return null;
}, MoreExecutors.directExecutor())));
return futures;
}
- private void handleTunnelMonitoringRemoval(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId,
+ private void handleTunnelMonitoringRemoval(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId,
String removedInterfaceName, IfTunnel ifTunnel) throws ExecutionException, InterruptedException {
interfaceManagerCommonUtils.removeTunnelIngressFlow(tx, ifTunnel, dpId, removedInterfaceName);
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.util.concurrent.ListenableFuture;
-
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.info("DataPathId found as null for Bridge Augmentation: {}... returning...", bridgeNew);
return Collections.emptyList();
}
- BigInteger dpnId = IfmUtil.getDpnId(bridgeNew.getDatapathId());
+ Uint64 dpnId = IfmUtil.getDpnId(bridgeNew.getDatapathId());
LOG.debug("adding bridge references for bridge: {}, dpn: {}", bridgeNew, dpnId);
// create bridge reference entry in interface meta operational DS
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
@Override
public List<ListenableFuture<Void>> call() {
- BigInteger dpnId = IfmUtil.getDpnId(bridgeNew.getDatapathId());
+ Uint64 dpnId = IfmUtil.getDpnId(bridgeNew.getDatapathId());
if (dpnId == null) {
LOG.warn("Got Null DPID for Bridge: {}", bridgeNew);
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
LOG.info("Scheduling port statistics request");
PortStatRequestTask portStatRequestTask = new PortStatRequestTask();
scheduledResult = portStatExecutorService.scheduleWithFixedDelay(portStatRequestTask,
- ifmConfig.getIfmStatsDefPollInterval(), ifmConfig.getIfmStatsDefPollInterval(), TimeUnit.MINUTES);
+ ifmConfig.getIfmStatsDefPollInterval().toJava(), ifmConfig.getIfmStatsDefPollInterval().toJava(),
+ TimeUnit.MINUTES);
}
/*
Futures.addCallback(ncStatsFuture, new FutureCallback<RpcResult<GetNodeConnectorStatisticsOutput>>() {
@Override
- public void onFailure(@NonNull Throwable error) {
+ public void onFailure(Throwable error) {
LOG.error("getNodeConnectorStatistics RPC failed for node: {} ", node, error);
}
Futures.addCallback(flowStatsFuture, new FutureCallback<RpcResult<GetFlowStatisticsOutput>>() {
@Override
- public void onFailure(@NonNull Throwable error) {
+ public void onFailure(Throwable error) {
LOG.error("getFlowStatistics RPC failed for node: {} ", node, error);
}
* - creates/updates new OF Port counters using Infrautils metrics API
* - set counter with values fetched from NodeConnectorStatistics
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void processNodeConnectorStatistics(GetNodeConnectorStatisticsOutput nodeConnectorStatisticsOutput,
String dpid) {
String port = "";
}
Counter counter = getCounter(CounterConstants.IFM_PORT_COUNTER_OFPORT_DURATION, dpid, port, portUuid,null);
- long ofPortDuration = ncStatsAndPortMap.getDuration().getSecond().getValue();
+ long ofPortDuration = ncStatsAndPortMap.getDuration().getSecond().getValue().toJava();
updateCounter(counter, ofPortDuration);
counter = getCounter(CounterConstants.IFM_PORT_COUNTER_OFPORT_PKT_RECVDROP, dpid, port, portUuid, null);
* - creates/updates Flow table counters using Infrautils metrics API
* - set counter with values fetched from FlowStatistics
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void processFlowStatistics(GetFlowStatisticsOutput flowStatsOutput, String dpid) {
Map<Short, AtomicInteger> flowTableMap = new HashMap<>();
// Get all flows for node from RPC result
List<FlowAndStatisticsMapList> flowTableAndStatisticsMapList =
flowStatsOutput.nonnullFlowAndStatisticsMapList();
for (FlowAndStatisticsMapList flowAndStatisticsMap : flowTableAndStatisticsMapList) {
- short tableId = flowAndStatisticsMap.getTableId();
+ short tableId = flowAndStatisticsMap.getTableId().toJava();
// populate map to maintain flow count per table
flowTableMap.computeIfAbsent(tableId, key -> new AtomicInteger(0)).incrementAndGet();
}
}
}
if (nodes.size() > 0) {
- delayStatsQuery = ifmConfig.getIfmStatsDefPollInterval() / nodes.size();
+ delayStatsQuery = ifmConfig.getIfmStatsDefPollInterval().toJava() / nodes.size();
} else {
stopPortStatRequestTask();
delayStatsQuery = 0;
return;
}
nodes.add(dpId);
- delayStatsQuery = ifmConfig.getIfmStatsDefPollInterval() / nodes.size();
+ delayStatsQuery = ifmConfig.getIfmStatsDefPollInterval().toJava() / nodes.size();
if (nodes.size() == 1) {
schedulePortStatRequestTask();
}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.math.BigInteger;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- BigInteger dpId = parentRefs.getDatapathNodeIdentifier();
+ Uint64 dpId = parentRefs.getDatapathNodeIdentifier();
if (dpId == null) {
LOG.warn("dpid for interface: {} Not Found. No DPID provided. " + "Creation of OF-Port not supported.",
interfaceNew.getName());
}
private long createLogicalTunnelSelectGroup(TypedWriteTransaction<Configuration> tx,
- BigInteger srcDpnId, String interfaceName, int lportTag) {
+ Uint64 srcDpnId, String interfaceName, int lportTag) {
long groupId = IfmUtil.getLogicalTunnelSelectGroupId(lportTag);
Group group = MDSALUtil.buildGroup(groupId, interfaceName, GroupTypes.GroupSelect,
MDSALUtil.buildBucketLists(Collections.emptyList()));
}
private void setupTunnelFlowsAndMonitoring(Interface interfaceNew, TypedWriteTransaction<Configuration> confTx,
- IfTunnel ifTunnel, BigInteger dpId,
+ IfTunnel ifTunnel, Uint64 dpId,
List<ListenableFuture<Void>> futures) {
// if TEP is already configured on switch, start LLDP monitoring and
// program tunnel ingress flow
}
@Override
- public void onFailure(@NonNull Throwable throwable) {
+ public void onFailure(Throwable throwable) {
LOG.error("Unable to add tunnel monitoring", throwable);
}
}, MoreExecutors.directExecutor());
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
cleanUpInterfaceWithUnknownState(interfaceName, parentRefs, null, tx);
- BigInteger dpId = IfmUtil.getDpnFromInterface(ifState);
+ Uint64 dpId = IfmUtil.getDpnFromInterface(ifState);
EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,REMOVE {}", interfaceName);
FlowBasedServicesUtils.removeIngressFlow(interfaceName, dpId, txRunner, futures);
TypedWriteTransaction<Operational> operTx, TypedReadWriteTransaction<Configuration> confTx)
throws ExecutionException, InterruptedException {
LOG.info("removing tunnel configuration for interface {}", interfaceName);
- BigInteger dpId = null;
+ Uint64 dpId = null;
if (parentRefs != null) {
dpId = parentRefs.getDatapathNodeIdentifier();
}
}
public void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> confTx,
- String interfaceName, IfTunnel ifTunnel, BigInteger dpId) throws ExecutionException, InterruptedException {
+ String interfaceName, IfTunnel ifTunnel, Uint64 dpId) throws ExecutionException, InterruptedException {
NodeConnectorId ncId = FlowBasedServicesUtils.getNodeConnectorIdFromInterface(interfaceName,
interfaceManagerCommonUtils);
if (ncId == null) {
private static class VlanMemberStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
private final ManagedNewTransactionRunner txRunner;
private final InterfaceManagerCommonUtils interfaceManagerCommonUtils;
- private final BigInteger dpId;
+ private final Uint64 dpId;
private final String interfaceName;
private final InterfaceParentEntry interfaceParentEntry;
VlanMemberStateRemoveWorker(ManagedNewTransactionRunner txRunner,
InterfaceManagerCommonUtils interfaceManagerCommonUtils,
- BigInteger dpId, String interfaceName, InterfaceParentEntry interfaceParentEntry) {
+ Uint64 dpId, String interfaceName, InterfaceParentEntry interfaceParentEntry) {
this.txRunner = txRunner;
this.interfaceManagerCommonUtils = interfaceManagerCommonUtils;
this.dpId = dpId;
}
private void removeLogicalTunnelSelectGroup(TypedReadWriteTransaction<Configuration> tx,
- BigInteger srcDpnId, String interfaceName, int lportTag) throws ExecutionException, InterruptedException {
+ Uint64 srcDpnId, String interfaceName, int lportTag) throws ExecutionException, InterruptedException {
long groupId = IfmUtil.getLogicalTunnelSelectGroupId(lportTag);
LOG.debug("MULTIPLE_VxLAN_TUNNELS: group id {} removed for {} srcDpnId {}",
groupId, interfaceName, srcDpnId);
mdsalApiManager.removeGroup(tx, srcDpnId, groupId);
}
- private void removeLogicalTunnelGroup(BigInteger dpnId, String ifaceName, int lportTag,
+ private void removeLogicalTunnelGroup(Uint64 dpnId, String ifaceName, int lportTag,
TypedWriteTransaction<Operational> operTx, TypedReadWriteTransaction<Configuration> confTx)
throws ExecutionException, InterruptedException {
LOG.debug("MULTIPLE_VxLAN_TUNNELS: unbind & delete Interface State for logic tunnel group {}", ifaceName);
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._interface.child.info._interface.parent.entry.InterfaceChildEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.getInterfaceState(tx, parentRefs.getParentInterface());
if (ifState != null) {
LOG.debug("delete vlan member interface state {}", interfaceOld.getName());
- BigInteger dpId = IfmUtil.getDpnFromInterface(ifState);
+ Uint64 dpId = IfmUtil.getDpnFromInterface(ifState);
interfaceManagerCommonUtils.deleteInterfaceStateInformation(interfaceOld.getName(), tx);
// TODO skitt The following is another configuration transaction, we'll deal with it later
FlowBasedServicesUtils.removeIngressFlow(interfaceOld.getName(), dpId, txRunner, futures);
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (InterfaceManagerCommonUtils.isVlanInterface(iface) && iface.isEnabled() && ifState
.getOperStatus() == org.opendaylight.yang.gen.v1.urn
.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus.Up) {
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
FlowBasedServicesUtils.installLportIngressFlow(dpId, portNo, iface, futures, txRunner,
ifState.getIfIndex());
futures.add(FlowBasedServicesUtils.bindDefaultEgressDispatcherService(txRunner, iface,
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.Interface interfaceInfo, String interfaceName, long portNo) {
EVENT_LOGGER.debug("IFM-OvsInterfaceState,ADD,TunnelIngressFlow {}", interfaceName);
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
ListenableFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
interfaceManagerCommonUtils.addTunnelIngressFlow(
tx, interfaceInfo.augmentation(IfTunnel.class), dpId, portNo, interfaceName, ifIndex);
}
@Override
- public void onFailure(@NonNull Throwable throwable) {
+ public void onFailure(Throwable throwable) {
LOG.error("Unable to add tunnel monitoring", throwable);
}
}, MoreExecutors.directExecutor());
public static boolean validateTunnelPortAttributes(NodeConnectorId nodeConnectorId,
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.Interface iface) {
- BigInteger currentDpnId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 currentDpnId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
if (iface != null) {
ParentRefs parentRefs = iface.augmentation(ParentRefs.class);
if (!currentDpnId.equals(parentRefs.getDatapathNodeIdentifier())) {
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfdStatus;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
OvsdbBridgeAugmentation bridgeNew,
OvsdbBridgeAugmentation bridgeOld) {
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
- BigInteger dpnIdNew = IfmUtil.getDpnId(bridgeNew.getDatapathId());
- BigInteger dpnIdOld = IfmUtil.getDpnId(bridgeOld.getDatapathId());
+ Uint64 dpnIdNew = IfmUtil.getDpnId(bridgeNew.getDatapathId());
+ Uint64 dpnIdOld = IfmUtil.getDpnId(bridgeOld.getDatapathId());
LOG.debug("updating bridge references for bridge: {}, dpnNew: {}, dpnOld: {}", bridgeNew,
dpnIdNew, dpnIdOld);
import com.google.common.collect.Maps;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.commons.lang3.BooleanUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// To keep the mapping between Tunnel Types and Tunnel Interfaces
private static final Map<Class<? extends TunnelTypeBase>, Class<? extends InterfaceTypeBase>>
- TUNNEL_TYPE_MAP = new HashMap<Class<? extends TunnelTypeBase>, Class<? extends InterfaceTypeBase>>() {
+ TUNNEL_TYPE_MAP = new HashMap<>() {
{
put(TunnelTypeGre.class, InterfaceTypeGre.class);
put(TunnelTypeMplsOverGre.class, InterfaceTypeGre.class);
int vlanId = 0;
IfL2vlan ifL2vlan = iface.augmentation(IfL2vlan.class);
if (ifL2vlan != null && ifL2vlan.getVlanId() != null) {
- vlanId = ifL2vlan.getVlanId().getValue();
+ vlanId = ifL2vlan.getVlanId().getValue().toJava();
}
Map<String, String> options = Maps.newHashMap();
public static boolean ifBfdStatusNotEqual(OvsdbTerminationPointAugmentation tpOld,
OvsdbTerminationPointAugmentation tpNew) {
- return (tpNew.getInterfaceBfdStatus() != null
- && (tpOld == null || !tpNew.getInterfaceBfdStatus().equals(tpOld.getInterfaceBfdStatus())));
+ return tpNew.getInterfaceBfdStatus() != null
+ && (tpOld == null || !tpNew.getInterfaceBfdStatus().equals(tpOld.getInterfaceBfdStatus()));
}
public static boolean changeInBfdMonitoringDetected(OvsdbTerminationPointAugmentation tpOld,
}
@SuppressFBWarnings("DM_DEFAULT_ENCODING")
- public static String generateOfTunnelName(BigInteger dpId, IfTunnel ifTunnel) {
+ public static String generateOfTunnelName(Uint64 dpId, IfTunnel ifTunnel) {
String sourceKey = ifTunnel.getTunnelSource().stringValue();
String remoteKey = ifTunnel.getTunnelDestination().stringValue();
if (ifTunnel.isTunnelSourceIpFlow() != null) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager.rpcservice;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.get.dpn._interface.list.output.InterfacesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public ListenableFuture<GetDpidFromInterfaceOutput> getDpidFromInterface(GetDpidFromInterfaceInput input) {
String interfaceName = input.getIntfName();
- BigInteger dpId;
+ Uint64 dpId;
InterfaceKey interfaceKey = new InterfaceKey(interfaceName);
Interface interfaceInfo = interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey);
if (interfaceInfo == null) {
public ListenableFuture<GetEgressInstructionsForInterfaceOutput> getEgressInstructionsForInterface(
GetEgressInstructionsForInterfaceInput input) {
List<Instruction> instructions = IfmUtil.getEgressInstructionsForInterface(input.getIntfName(),
- input.getTunnelKey(), interfaceManagerCommonUtils, false);
+ input.getTunnelKey().toJava(), interfaceManagerCommonUtils, false);
return Futures.immediateFuture(
new GetEgressInstructionsForInterfaceOutputBuilder().setInstruction(instructions).build());
}
@Override
public ListenableFuture<GetEgressActionsForInterfaceOutput> getEgressActionsForInterface(
GetEgressActionsForInterfaceInput input) {
- List<Action> actionsList = IfmUtil.getEgressActionsForInterface(input.getIntfName(), input.getTunnelKey(),
- input.getActionKey(), interfaceManagerCommonUtils, false);
+ List<Action> actionsList = IfmUtil.getEgressActionsForInterface(input.getIntfName(),
+ input.getTunnelKey().toJava(), input.getActionKey(), interfaceManagerCommonUtils, false);
// TODO as above, simplify the success case later, as we have the failure case below
return Futures
.immediateFuture(new GetEgressActionsForInterfaceOutputBuilder().setAction(actionsList).build());
@Override
public ListenableFuture<GetPortFromInterfaceOutput> getPortFromInterface(GetPortFromInterfaceInput input) {
String interfaceName = input.getIntfName();
- BigInteger dpId = null;
+ Uint64 dpId = null;
long portNo = 0;
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface ifState = interfaceManagerCommonUtils
@Override
public ListenableFuture<GetDpnInterfaceListOutput> getDpnInterfaceList(GetDpnInterfaceListInput input) {
- BigInteger dpnid = input.getDpid();
+ Uint64 dpnid = input.getDpid();
InstanceIdentifier<DpnToInterface> id = InstanceIdentifier.builder(DpnToInterfaceList.class)
.child(DpnToInterface.class, new DpnToInterfaceKey(dpnid)).build();
Optional<DpnToInterface> entry = IfmUtil.read(LogicalDatastoreType.OPERATIONAL, id, dataBroker);
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected void bindServiceOnInterface(List<ListenableFuture<Void>> futures, BoundServices boundServiceNew,
List<BoundServices> allServices, BoundServicesState boundServiceState) {
- BigInteger dpId = boundServiceState.getDpid();
+ Uint64 dpId = boundServiceState.getDpid();
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
Interface iface =
interfaceManagerCommonUtils.getInterfaceFromConfigDS(boundServiceState.getInterfaceName());
// some value since this is the only service bound.
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, boundServiceNew,
boundServiceState.getInterfaceName(), tx, boundServiceState.getIfIndex(),
- NwConstants.DEFAULT_SERVICE_INDEX, (short) (boundServiceNew.getServicePriority() + 1), iface);
+ NwConstants.DEFAULT_SERVICE_INDEX, (short) (boundServiceNew.getServicePriority().toJava() + 1),
+ iface);
return;
}
allServices.remove(boundServiceNew);
NwConstants.DEFAULT_EGRESS_SERVICE_INDEX); // dummy service
// index
if (low != null) {
- nextServiceIndex = low.getServicePriority();
+ nextServiceIndex = low.getServicePriority().toJava();
if (low.equals(highest)) {
// In this case the match criteria of existing service should be
// changed.
BoundServices lower = FlowBasedServicesUtils.getHighAndLowPriorityService(allServices, low)[0];
- short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority()
- : low.getServicePriority() + 1);
+ short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority().toJava()
+ : low.getServicePriority().toJava() + 1);
LOG.trace("Installing egress dispatcher table entry for existing service {} service match on "
+ "service index {} update with service index {}",
low, low.getServicePriority(), lowerServiceIndex);
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, low, boundServiceState.getInterfaceName(),
- tx, boundServiceState.getIfIndex(), low.getServicePriority(), lowerServiceIndex, iface);
+ tx, boundServiceState.getIfIndex(), low.getServicePriority().toJava(),
+ lowerServiceIndex, iface);
} else {
- currentServiceIndex = boundServiceNew.getServicePriority();
+ currentServiceIndex = boundServiceNew.getServicePriority().toJava();
}
}
if (high != null) {
- currentServiceIndex = boundServiceNew.getServicePriority();
+ currentServiceIndex = boundServiceNew.getServicePriority().toJava();
if (high.equals(highest)) {
LOG.trace("Installing egress dispatcher table entry for existing service {} service match on "
+ "service index {} update with service index {}",
high, high.getServicePriority(), currentServiceIndex);
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, high,
boundServiceState.getInterfaceName(), tx, boundServiceState.getIfIndex(),
- high.getServicePriority(), currentServiceIndex, iface);
+ high.getServicePriority().toJava(), currentServiceIndex, iface);
}
}
LOG.trace("Installing egress dispatcher table entry "
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
Interface iface =
interfaceManagerCommonUtils.getInterfaceFromConfigDS(boundServicesState.getInterfaceName());
- BigInteger dpId = boundServicesState.getDpid();
+ Uint64 dpId = boundServicesState.getDpid();
if (boundServices.isEmpty()) {
// Remove default entry from Lport Dispatcher Table.
FlowBasedServicesUtils.removeEgressDispatcherFlows(dpId, boundServicesState.getInterfaceName(),
LOG.trace("Deleting egress dispatcher table entry for lower service {}, match service index {}",
low, low.getServicePriority());
FlowBasedServicesUtils.removeEgressDispatcherFlows(dpId, boundServicesState.getInterfaceName(),
- tx, low.getServicePriority());
+ tx, low.getServicePriority().toJava());
BoundServices lower = FlowBasedServicesUtils.getHighAndLowPriorityService(boundServices, low)[0];
- short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority()
- : low.getServicePriority() + 1);
+ short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority().toJava()
+ : low.getServicePriority().toJava() + 1);
LOG.trace("Installing new egress dispatcher table entry for lower service {}, match service index "
+ "{}, update service index {}",
low, NwConstants.DEFAULT_SERVICE_INDEX, lowerServiceIndex);
}
} else {
LOG.trace("Deleting egress dispatcher table entry for service {}, match service index {}",
- boundServiceOld, boundServiceOld.getServicePriority());
+ boundServiceOld, boundServiceOld.getServicePriority().toJava());
FlowBasedServicesUtils.removeEgressDispatcherFlows(dpId, boundServicesState.getInterfaceName(),
- tx, boundServiceOld.getServicePriority());
- short lowerServiceIndex = (short) (low != null ? low.getServicePriority()
- : boundServiceOld.getServicePriority() + 1);
+ tx, boundServiceOld.getServicePriority().toJava());
+ short lowerServiceIndex = (short) (low != null ? low.getServicePriority().toJava()
+ : boundServiceOld.getServicePriority().toJava() + 1);
BoundServices highest = FlowBasedServicesUtils.getHighestPriorityService(boundServices);
if (high.equals(highest)) {
LOG.trace("Update the existing higher service {}, match service index {}, update service index {}",
NwConstants.DEFAULT_SERVICE_INDEX, lowerServiceIndex, iface);
} else {
LOG.trace("Update the existing higher service {}, match service index {}, update service index {}",
- high, high.getServicePriority(), lowerServiceIndex);
+ high, high.getServicePriority().toJava(), lowerServiceIndex);
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, high,
boundServicesState.getInterfaceName(), tx, boundServicesState.getIfIndex(),
- high.getServicePriority(), lowerServiceIndex, iface);
+ high.getServicePriority().toJava(), lowerServiceIndex, iface);
}
}
}));
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private void bindServiceOnTunnel(List<ListenableFuture<Void>> futures, BoundServices boundServiceNew,
List<BoundServices> allServices, BoundServicesState boundServiceState) {
- long portNo = boundServiceState.getPortNo();
- BigInteger dpId = boundServiceState.getDpid();
+ long portNo = boundServiceState.getPortNo().toJava();
+ Uint64 dpId = boundServiceState.getDpid();
LOG.info("binding ingress service {} for tunnel port: {}", boundServiceNew.getServiceName(),
boundServiceState.getInterfaceName());
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
Map<Short, BoundServices> tmpServicesMap = new ConcurrentHashMap<>();
short highestPriority = 0xFF;
for (BoundServices boundService : allServices) {
- if (boundService.getServicePriority() < boundServiceNew.getServicePriority()) {
+ if (boundService.getServicePriority().toJava() < boundServiceNew.getServicePriority().toJava()) {
isCurrentServiceHighestPriority = false;
break;
}
if (!boundService.equals(boundServiceNew)) {
- tmpServicesMap.put(boundService.getServicePriority(), boundService);
- if (boundService.getServicePriority() < highestPriority) {
- highestPriority = boundService.getServicePriority();
+ tmpServicesMap.put(boundService.getServicePriority().toJava(), boundService);
+ if (boundService.getServicePriority().toJava() < highestPriority) {
+ highestPriority = boundService.getServicePriority().toJava();
}
}
}
if (!isCurrentServiceHighestPriority) {
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, boundServiceNew,
boundServiceState.getInterfaceName(), tx, boundServiceState.getIfIndex(),
- boundServiceNew.getServicePriority(), (short) (boundServiceNew.getServicePriority() + 1));
+ boundServiceNew.getServicePriority().toJava(),
+ (short) (boundServiceNew.getServicePriority().toJava() + 1));
} else {
BoundServices serviceToReplace = tmpServicesMap.get(highestPriority);
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, serviceToReplace,
boundServiceState.getInterfaceName(), tx, boundServiceState.getIfIndex(),
- serviceToReplace.getServicePriority(), (short) (serviceToReplace.getServicePriority() + 1));
+ serviceToReplace.getServicePriority().toJava(),
+ (short) (serviceToReplace.getServicePriority().toJava() + 1));
List<MatchInfo> matches = FlowBasedServicesUtils.getMatchInfoForTunnelPortAtIngressTable(dpId, portNo);
// Separate transactions to remove and install flows
private void bindServiceOnVlan(List<ListenableFuture<Void>> futures, BoundServices boundServiceNew,
List<BoundServices> allServices, BoundServicesState boundServiceState) {
- BigInteger dpId = boundServiceState.getDpid();
+ Uint64 dpId = boundServiceState.getDpid();
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
LOG.info("binding ingress service {} for vlan port: {}", boundServiceNew.getServiceName(), boundServiceState
.getInterfaceName());
// service bound.
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, boundServiceNew,
boundServiceState.getInterfaceName(), tx, boundServiceState.getIfIndex(),
- NwConstants.DEFAULT_SERVICE_INDEX, (short) (boundServiceNew.getServicePriority() + 1));
+ NwConstants.DEFAULT_SERVICE_INDEX, (short) (boundServiceNew.getServicePriority().toJava() + 1));
return;
}
allServices.remove(boundServiceNew);
BoundServices high = highLowPriorityService[1];
BoundServices highest = FlowBasedServicesUtils.getHighestPriorityService(allServices);
short currentServiceIndex = NwConstants.DEFAULT_SERVICE_INDEX;
- short nextServiceIndex = (short) (boundServiceNew.getServicePriority() + 1); // dummy
+ short nextServiceIndex = (short) (boundServiceNew.getServicePriority().toJava() + 1); // dummy
// service
// index
if (low != null) {
- nextServiceIndex = low.getServicePriority();
+ nextServiceIndex = low.getServicePriority().toJava();
if (low.equals(highest)) {
// In this case the match criteria of existing service should be
// changed.
BoundServices lower = FlowBasedServicesUtils.getHighAndLowPriorityService(allServices, low)[0];
- short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority()
- : low.getServicePriority() + 1);
+ short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority().toJava()
+ : low.getServicePriority().toJava() + 1);
LOG.trace("Installing ingress dispatcher table entry for existing service {} service match on "
+ "service index {} update with service index {}",
low, low.getServicePriority(), lowerServiceIndex);
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, low, boundServiceState.getInterfaceName(),
- tx, boundServiceState.getIfIndex(), low.getServicePriority(), lowerServiceIndex);
+ tx, boundServiceState.getIfIndex(), low.getServicePriority().toJava(), lowerServiceIndex);
} else {
- currentServiceIndex = boundServiceNew.getServicePriority();
+ currentServiceIndex = boundServiceNew.getServicePriority().toJava();
}
}
if (high != null) {
- currentServiceIndex = boundServiceNew.getServicePriority();
+ currentServiceIndex = boundServiceNew.getServicePriority().toJava();
if (high.equals(highest)) {
LOG.trace("Installing ingress dispatcher table entry for existing service {} service match on "
+ "service index {} update with service index {}",
} else {
LOG.trace("Installing ingress dispatcher table entry for existing service {} service match on "
+ "service index {} update with service index {}",
- high, high.getServicePriority(), currentServiceIndex);
+ high, high.getServicePriority().toJava(), currentServiceIndex);
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, high, boundServiceState.getInterfaceName(),
- tx, boundServiceState.getIfIndex(), high.getServicePriority(), currentServiceIndex);
+ tx, boundServiceState.getIfIndex(), high.getServicePriority().toJava(),
+ currentServiceIndex);
}
}
LOG.trace("Installing ingress dispatcher table entry for new service match on service index {} update with "
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.bound.services.state.list.BoundServicesState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.info("unbinding ingress service {} for vlan port: {}", boundServiceOld.getServiceName(),
boundServicesState.getInterfaceName());
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- BigInteger dpId = boundServicesState.getDpid();
+ Uint64 dpId = boundServicesState.getDpid();
if (boundServices == null || boundServices.isEmpty()) {
// Remove default entry from Lport Dispatcher Table.
FlowBasedServicesUtils.removeLPortDispatcherFlow(dpId, boundServicesState.getInterfaceName(),
if (low != null) {
// delete the lower services flow entry.
LOG.trace("Deleting ingress dispatcher table entry for lower service {}, match service index {}",
- low, low.getServicePriority());
+ low, low.getServicePriority().toJava());
FlowBasedServicesUtils.removeLPortDispatcherFlow(dpId, boundServicesState.getInterfaceName(), low,
- tx, low.getServicePriority());
+ tx, low.getServicePriority().toJava());
BoundServices lower = FlowBasedServicesUtils.getHighAndLowPriorityService(boundServices, low)[0];
- short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority()
- : low.getServicePriority() + 1);
+ short lowerServiceIndex = (short) (lower != null ? lower.getServicePriority().toJava()
+ : low.getServicePriority().toJava() + 1);
LOG.trace("Installing new ingress dispatcher table entry for lower service {}, match service index "
+ "{}, update service index {}",
low, NwConstants.DEFAULT_SERVICE_INDEX, lowerServiceIndex);
LOG.trace("Deleting ingress dispatcher table entry for service {}, match service index {}",
boundServiceOld, boundServiceOld.getServicePriority());
FlowBasedServicesUtils.removeLPortDispatcherFlow(dpId, boundServicesState.getInterfaceName(),
- boundServiceOld, tx, boundServiceOld.getServicePriority());
- short lowerServiceIndex = (short) (low != null ? low.getServicePriority()
- : boundServiceOld.getServicePriority() + 1);
+ boundServiceOld, tx, boundServiceOld.getServicePriority().toJava());
+ short lowerServiceIndex = (short) (low != null ? low.getServicePriority().toJava()
+ : boundServiceOld.getServicePriority().toJava() + 1);
BoundServices highest = FlowBasedServicesUtils.getHighestPriorityService(boundServices);
if (high.equals(highest)) {
LOG.trace("Update the existing higher service {}, match service index {}, update service index {}",
LOG.trace("Update the existing higher service {}, match service index {}, update service index {}",
high, high.getServicePriority(), lowerServiceIndex);
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, high, boundServicesState.getInterfaceName(),
- tx, boundServicesState.getIfIndex(), high.getServicePriority(), lowerServiceIndex);
+ tx, boundServicesState.getIfIndex(), high.getServicePriority().toJava(), lowerServiceIndex);
}
}
}));
private void unbindServiceOnTunnel(List<ListenableFuture<Void>> futures, BoundServices boundServiceOld,
List<BoundServices> boundServices, BoundServicesState boundServicesState) {
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- BigInteger dpId = boundServicesState.getDpid();
+ Uint64 dpId = boundServicesState.getDpid();
LOG.info("unbinding ingress service {} for tunnel port: {}", boundServiceOld.getServiceName(),
boundServicesState.getInterfaceName());
Map<Short, BoundServices> tmpServicesMap = new ConcurrentHashMap<>();
short highestPriority = 0xFF;
for (BoundServices boundService : boundServices) {
- tmpServicesMap.put(boundService.getServicePriority(), boundService);
- if (boundService.getServicePriority() < highestPriority) {
- highestPriority = boundService.getServicePriority();
+ tmpServicesMap.put(boundService.getServicePriority().toJava(), boundService);
+ if (boundService.getServicePriority().toJava() < highestPriority) {
+ highestPriority = boundService.getServicePriority().toJava();
}
}
- if (highestPriority < boundServiceOld.getServicePriority()) {
+ if (highestPriority < boundServiceOld.getServicePriority().toJava()) {
FlowBasedServicesUtils.removeLPortDispatcherFlow(dpId, boundServicesState.getInterfaceName(),
- boundServiceOld, tx, boundServiceOld.getServicePriority());
+ boundServiceOld, tx, boundServiceOld.getServicePriority().toJava());
return;
}
List<MatchInfo> matches;
- long portNo = boundServicesState.getPortNo();
+ long portNo = boundServicesState.getPortNo().toJava();
matches = FlowBasedServicesUtils.getMatchInfoForTunnelPortAtIngressTable(dpId, portNo);
BoundServices toBeMoved = tmpServicesMap.get(highestPriority);
FlowBasedServicesUtils.installInterfaceIngressFlow(dpId, iface, toBeMoved, tx, matches,
boundServicesState.getIfIndex(), NwConstants.VLAN_INTERFACE_INGRESS_TABLE);
FlowBasedServicesUtils.removeLPortDispatcherFlow(dpId, iface.getName(), toBeMoved, tx,
- toBeMoved.getServicePriority());
+ toBeMoved.getServicePriority().toJava());
}));
}
* and the functionality will remain same for all other applications as it was earlier.
*/
if (boundServiceNew.getServicePriority() != null && (
- boundServiceNew.getServicePriority() == NwConstants.ACL_SERVICE_INDEX
- || boundServiceNew.getServicePriority() == NwConstants.EGRESS_ACL_SERVICE_INDEX)
+ boundServiceNew.getServicePriority().toJava() == NwConstants.ACL_SERVICE_INDEX
+ || boundServiceNew.getServicePriority().toJava() == NwConstants.EGRESS_ACL_SERVICE_INDEX)
&& !Objects.equals(boundServiceOld, boundServiceNew)) {
LOG.info("Bound services flow update for service {}", boundServiceNew.getServiceName());
add(serviceKey, boundServiceNew, boundServicesList);
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.listeners;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void add(@NonNull InstanceIdentifier<Node> instanceIdentifier, @NonNull Node node) {
- final BigInteger dpId = getDpnID(node);
+ final Uint64 dpId = getDpnID(node);
if (dpId == null) {
return;
}
bindServicesOnTunnelType(dpId);
}
- private void bindServicesOnTunnelType(final BigInteger dpId) {
+ private void bindServicesOnTunnelType(final Uint64 dpId) {
LOG.debug("Received node add event for {}", dpId);
for (final Class<?extends ServiceModeBase> serviceMode : FlowBasedServicesUtils.SERVICE_MODE_MAP.values()) {
for (final String interfaceName : FlowBasedServicesUtils.INTERFACE_TYPE_BASED_SERVICE_BINDING_KEYWORDS) {
private static class RendererStateInterfaceBindWorker implements Callable<List<ListenableFuture<Void>>> {
private final String iface;
- final BigInteger dpnId;
+ final Uint64 dpnId;
final FlowBasedServicesStateAddable flowBasedServicesStateAddable;
RendererStateInterfaceBindWorker(final FlowBasedServicesStateAddable flowBasedServicesStateAddable,
- final BigInteger dpnId,
+ final Uint64 dpnId,
final String iface) {
this.flowBasedServicesStateAddable = flowBasedServicesStateAddable;
this.dpnId = dpnId;
}
}
- private BigInteger getDpnID(final Node id) {
+ private static Uint64 getDpnID(final Node id) {
final String[] node = id.getId().getValue().split(":");
if (node.length < 2) {
LOG.warn("Unexpected nodeId {}", id.getId().getValue());
return null;
}
- return new BigInteger(node[1]);
+ return Uint64.valueOf(node[1]);
}
}
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface FlowBasedServicesStateAddable {
void bindServices(List<ListenableFuture<Void>> futures, Interface ifaceState, List<BoundServices> allServices,
Class<? extends ServiceModeBase> serviceMode);
- void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, BigInteger dpnId, String ifaceName);
+ void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, Uint64 dpnId, String ifaceName);
}
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.factory;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface FlowBasedServicesStateRemovable {
void unbindServices(List<ListenableFuture<Void>> futures, Interface ifaceState,
Class<? extends ServiceModeBase> serviceMode);
- void unbindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, BigInteger dpnId, String ifaceName);
+ void unbindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, Uint64 dpnId, String ifaceName);
}
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
List<BoundServices> allServices, Interface ifState);
@Override
- public abstract void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, BigInteger dpnId,
+ public abstract void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, Uint64 dpnId,
String ifaceName);
}
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.helpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Comparator;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Interface ifState) {
LOG.info("bind all egress services for interface: {}", ifState.getName());
NodeConnectorId nodeConnectorId = FlowBasedServicesUtils.getNodeConnectorIdFromInterface(ifState);
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
allServices.sort(Comparator.comparing(BoundServices::getServicePriority));
BoundServices highestPriority = allServices.remove(0);
- short nextServiceIndex = (short) (allServices.size() > 0 ? allServices.get(0).getServicePriority()
- : highestPriority.getServicePriority() + 1);
+ short nextServiceIndex = (short) (allServices.size() > 0 ? allServices.get(0).getServicePriority().toJava()
+ : highestPriority.getServicePriority().toJava() + 1);
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.Interface iface = interfaceManagerCommonUtils
.getInterfaceFromConfigDS(ifState.getName());
for (BoundServices boundService : allServices) {
if (prev != null) {
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, prev, ifState.getName(), tx,
- ifState.getIfIndex(), prev.getServicePriority(), boundService.getServicePriority(), iface);
+ ifState.getIfIndex(), prev.getServicePriority().toJava(),
+ boundService.getServicePriority().toJava(), iface);
}
prev = boundService;
}
if (prev != null) {
FlowBasedServicesUtils.installEgressDispatcherFlows(dpId, prev, ifState.getName(), tx,
- ifState.getIfIndex(), prev.getServicePriority(), (short) (prev.getServicePriority() + 1),
- iface);
+ ifState.getIfIndex(), prev.getServicePriority().toJava(),
+ (short) (prev.getServicePriority().toJava() + 1), iface);
}
}
@Override
- public void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, BigInteger dpnId, String ifaceName) {
+ public void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, Uint64 dpnId, String ifaceName) {
+ // TODO: No-op?
}
}
package org.opendaylight.genius.interfacemanager.servicebindings.flowbased.state.helpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Comparator;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.getInterfaceFromConfigDS(ifState.getName());
NodeConnectorId nodeConnectorId = FlowBasedServicesUtils.getNodeConnectorIdFromInterface(ifState);
long portNo = IfmUtil.getPortNumberFromNodeConnectorId(nodeConnectorId);
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
List<MatchInfo> matches = FlowBasedServicesUtils.getMatchInfoForTunnelPortAtIngressTable(dpId, portNo);
BoundServices highestPriorityBoundService = FlowBasedServicesUtils.getHighestPriorityService(allServices);
FlowBasedServicesUtils.installInterfaceIngressFlow(dpId, iface, highestPriorityBoundService,
for (BoundServices boundService : allServices) {
if (!boundService.equals(highestPriorityBoundService)) {
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, boundService, ifState.getName(),
- tx, ifState.getIfIndex(), boundService.getServicePriority(),
- (short) (boundService.getServicePriority() + 1));
+ tx, ifState.getIfIndex(), boundService.getServicePriority().toJava(),
+ (short) (boundService.getServicePriority().toJava() + 1));
}
}
}
Interface ifState) {
LOG.info("bind all ingress services for vlan port: {}", ifState.getName());
NodeConnectorId nodeConnectorId = FlowBasedServicesUtils.getNodeConnectorIdFromInterface(ifState);
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
allServices.sort(Comparator.comparing(BoundServices::getServicePriority));
BoundServices highestPriority = allServices.remove(0);
- short nextServiceIndex = (short) (allServices.size() > 0 ? allServices.get(0).getServicePriority()
- : highestPriority.getServicePriority() + 1);
+ short nextServiceIndex = (short) (allServices.size() > 0 ? allServices.get(0).getServicePriority().toJava()
+ : highestPriority.getServicePriority().toJava() + 1);
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, highestPriority, ifState.getName(), tx,
ifState.getIfIndex(), NwConstants.DEFAULT_SERVICE_INDEX, nextServiceIndex);
BoundServices prev = null;
for (BoundServices boundService : allServices) {
if (prev != null) {
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, prev, ifState.getName(), tx,
- ifState.getIfIndex(), prev.getServicePriority(), boundService.getServicePriority());
+ ifState.getIfIndex(), prev.getServicePriority().toJava(),
+ boundService.getServicePriority().toJava());
}
prev = boundService;
}
if (prev != null) {
FlowBasedServicesUtils.installLPortDispatcherFlow(dpId, prev, ifState.getName(), tx,
- ifState.getIfIndex(), prev.getServicePriority(), (short) (prev.getServicePriority() + 1));
+ ifState.getIfIndex(), prev.getServicePriority().toJava(),
+ (short) (prev.getServicePriority().toJava() + 1));
}
}
@Override
- public void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, BigInteger dpnId, String ifaceName) {
+ public void bindServicesOnInterfaceType(List<ListenableFuture<Void>> futures, Uint64 dpnId, String ifaceName) {
+ // FIXME: does this mean this is not finished?
LOG.info("bindServicesOnInterfaceType Ingress - WIP");
}
}
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowjava.nx.match.rev140421.NxmNxReg6;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Nullable
- public static BigInteger getDpnIdFromInterface(
+ public static Uint64 getDpnIdFromInterface(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
.ietf.interfaces.rev140508.interfaces.state.Interface ifState) {
if (ifState != null) {
return null;
}
- public static List<MatchInfo> getMatchInfoForVlanPortAtIngressTable(BigInteger dpId, long portNo, Interface iface) {
+ public static List<MatchInfo> getMatchInfoForVlanPortAtIngressTable(Uint64 dpId, long portNo, Interface iface) {
List<MatchInfo> matches = new ArrayList<>();
matches.add(new MatchInPort(dpId, portNo));
int vlanId = 0;
IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
if (l2vlan != null) {
- vlanId = l2vlan.getVlanId() == null ? 0 : l2vlan.getVlanId().getValue();
+ vlanId = l2vlan.getVlanId() == null ? 0 : l2vlan.getVlanId().getValue().toJava();
}
if (vlanId >= 0 && l2vlan.getL2vlanMode() != IfL2vlan.L2vlanMode.Transparent) {
matches.add(new MatchVlanVid(vlanId));
}
@NonNull
- public static List<MatchInfo> getMatchInfoForTunnelPortAtIngressTable(BigInteger dpId, long portNo) {
+ public static List<MatchInfo> getMatchInfoForTunnelPortAtIngressTable(Uint64 dpId, long portNo) {
List<MatchInfo> matches = new ArrayList<>();
matches.add(new MatchInPort(dpId, portNo));
return matches;
return matches;
}
- public static void installInterfaceIngressFlow(BigInteger dpId, Interface iface, BoundServices boundServiceNew,
+ public static void installInterfaceIngressFlow(Uint64 dpId, Interface iface, BoundServices boundServiceNew,
TypedWriteTransaction<Configuration> tx, List<MatchInfo> matches, int lportTag, short tableId) {
List<Instruction> instructions = boundServiceNew.augmentation(StypeOpenflow.class).getInstruction();
int vlanId = 0;
IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
if (l2vlan != null && l2vlan.getVlanId() != null) {
- vlanId = l2vlan.getVlanId().getValue();
+ vlanId = l2vlan.getVlanId().getValue().toJava();
}
if (vlanId != 0) {
// incrementing instructionSize and using it as actionKey. Because
}
if (lportTag != 0L) {
- BigInteger[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(instructions);
- short index = boundServiceNew.getServicePriority();
- BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag, ++index, metadataValues[0],
+ Uint64[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(instructions);
+ short index = boundServiceNew.getServicePriority().toJava();
+ Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag, ++index, metadataValues[0],
isExternal(iface));
- BigInteger metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(
+ Uint64 metadataMask = MetaDataUtil.getMetaDataMaskForLPortDispatcher(
MetaDataUtil.METADATA_MASK_SERVICE_INDEX, MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG,
metadataValues[1]);
instructionSet.add(
String serviceRef = boundServiceNew.getServiceName();
String flowRef = getFlowRef(dpId, NwConstants.VLAN_INTERFACE_INGRESS_TABLE, iface.getName(),
- boundServiceNew.getServicePriority());
+ boundServiceNew.getServicePriority().toJava());
StypeOpenflow stypeOpenflow = boundServiceNew.augmentation(StypeOpenflow.class);
- Flow ingressFlow = MDSALUtil.buildFlowNew(tableId, flowRef, stypeOpenflow.getFlowPriority(), serviceRef, 0, 0,
- stypeOpenflow.getFlowCookie(), matches, instructionSet);
+ Flow ingressFlow = MDSALUtil.buildFlowNew(tableId, flowRef, stypeOpenflow.getFlowPriority().toJava(),
+ serviceRef, 0, 0, stypeOpenflow.getFlowCookie(), matches, instructionSet);
installFlow(dpId, ingressFlow, tx);
}
- public static void installFlow(BigInteger dpId, Flow flow, TypedWriteTransaction<Configuration> writeTransaction) {
+ public static void installFlow(Uint64 dpId, Flow flow, TypedWriteTransaction<Configuration> writeTransaction) {
FlowKey flowKey = new FlowKey(new FlowId(flow.getId()));
Node nodeDpn = buildInventoryDpnNode(dpId);
InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
EVENT_LOGGER.debug("IFM,InstallFlow {}", flow.getId());
}
- private static Node buildInventoryDpnNode(BigInteger dpnId) {
+ private static Node buildInventoryDpnNode(Uint64 dpnId) {
NodeId nodeId = new NodeId("openflow:" + dpnId);
return new NodeBuilder().setId(nodeId).withKey(new NodeKey(nodeId)).build();
}
- public static void installLPortDispatcherFlow(BigInteger dpId, BoundServices boundService, String interfaceName,
+ public static void installLPortDispatcherFlow(Uint64 dpId, BoundServices boundService, String interfaceName,
TypedWriteTransaction<Configuration> tx, int interfaceTag, short currentServiceIndex,
short nextServiceIndex) {
String serviceRef = boundService.getServiceName();
StypeOpenflow stypeOpenFlow = boundService.augmentation(StypeOpenflow.class);
List<Instruction> serviceInstructions = stypeOpenFlow.getInstruction();
int instructionSize = serviceInstructions != null ? serviceInstructions.size() : 0;
- BigInteger[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
- BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, nextServiceIndex,
+ Uint64[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
+ Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(interfaceTag, nextServiceIndex,
metadataValues[0]);
- BigInteger metadataMask = MetaDataUtil.getWriteMetaDataMaskForDispatcherTable();
+ Uint64 metadataMask = MetaDataUtil.getWriteMetaDataMaskForDispatcherTable();
// build the final instruction for LPort Dispatcher table flow entry
List<Instruction> instructions = new ArrayList<>();
String flowRef = getFlowRef(dpId, NwConstants.LPORT_DISPATCHER_TABLE, interfaceName,
currentServiceIndex);
Flow ingressFlow = MDSALUtil.buildFlowNew(NwConstants.LPORT_DISPATCHER_TABLE, flowRef,
- DEFAULT_DISPATCHER_PRIORITY, serviceRef, 0, 0, stypeOpenFlow.getFlowCookie(), matches,
- instructions);
+ DEFAULT_DISPATCHER_PRIORITY, serviceRef, 0, 0, stypeOpenFlow.getFlowCookie(), matches, instructions);
LOG.debug("Installing LPort Dispatcher Flow on DPN {}, for interface {}, with flowRef {}", dpId,
interfaceName, flowRef);
installFlow(dpId, ingressFlow, tx);
}
- public static void installEgressDispatcherFlows(BigInteger dpId, BoundServices boundService, String interfaceName,
+ public static void installEgressDispatcherFlows(Uint64 dpId, BoundServices boundService, String interfaceName,
TypedWriteTransaction<Configuration> tx, int interfaceTag, short currentServiceIndex,
short nextServiceIndex, Interface iface) {
LOG.debug("Installing Egress Dispatcher Flows on dpn : {}, for interface : {}", dpId, interfaceName);
// this flow drops traffic targeted to external interfaces if they
// arrived
// from an external interface (marked with the SH bit)
- if (boundService.getServicePriority() == ServiceIndex.getIndex(NwConstants.DEFAULT_EGRESS_SERVICE_NAME,
+ if (boundService.getServicePriority().toJava() == ServiceIndex.getIndex(NwConstants.DEFAULT_EGRESS_SERVICE_NAME,
NwConstants.DEFAULT_EGRESS_SERVICE_INDEX)) {
installEgressDispatcherSplitHorizonFlow(dpId, boundService, interfaceName, tx, interfaceTag,
currentServiceIndex, iface);
}
}
- private static void installEgressDispatcherFlow(BigInteger dpId, BoundServices boundService, String interfaceName,
+ private static void installEgressDispatcherFlow(Uint64 dpId, BoundServices boundService, String interfaceName,
TypedWriteTransaction<Configuration> tx, int interfaceTag, short currentServiceIndex,
short nextServiceIndex) {
// build the final instruction for LPort Dispatcher table flow entry
List<Action> finalApplyActions = new ArrayList<>();
List<Instruction> instructions = new ArrayList<>();
- if (boundService.getServicePriority() != ServiceIndex.getIndex(NwConstants.DEFAULT_EGRESS_SERVICE_NAME,
+ if (boundService.getServicePriority().toJava() != ServiceIndex.getIndex(NwConstants.DEFAULT_EGRESS_SERVICE_NAME,
NwConstants.DEFAULT_EGRESS_SERVICE_INDEX)) {
- BigInteger[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
- BigInteger metadataMask = MetaDataUtil.getWriteMetaDataMaskForEgressDispatcherTable();
+ Uint64[] metadataValues = IfmUtil.mergeOpenflowMetadataWriteInstructions(serviceInstructions);
+ Uint64 metadataMask = MetaDataUtil.getWriteMetaDataMaskForEgressDispatcherTable();
instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadataValues[0], metadataMask,
instructions.size()));
finalApplyActions.add(MDSALUtil.createSetReg6Action(finalApplyActions.size(), 0, 31,
String flowRef = getFlowRef(dpId, NwConstants.EGRESS_LPORT_DISPATCHER_TABLE, interfaceName,
currentServiceIndex);
Flow egressFlow = MDSALUtil.buildFlowNew(NwConstants.EGRESS_LPORT_DISPATCHER_TABLE, flowRef,
- boundService.getServicePriority(), serviceRef, 0, 0, stypeOpenflow.getFlowCookie(), matches,
- instructions);
+ boundService.getServicePriority().toJava(), serviceRef, 0, 0, stypeOpenflow.getFlowCookie(),
+ matches, instructions);
LOG.debug("Installing Egress Dispatcher Flow for interface : {}, with flow-ref : {}", interfaceName, flowRef);
installFlow(dpId, egressFlow, tx);
}
- public static void installEgressDispatcherSplitHorizonFlow(BigInteger dpId, BoundServices boundService,
+ public static void installEgressDispatcherSplitHorizonFlow(Uint64 dpId, BoundServices boundService,
String interfaceName, TypedWriteTransaction<Configuration> tx, int interfaceTag, short currentServiceIndex,
Interface iface) {
// only install split horizon drop flows for external interfaces
LOG.debug("Installing split horizon drop flow for external interface {} on dpId {}", interfaceName, dpId);
}
- BigInteger shFlagSet = BigInteger.ONE; // BigInteger.ONE is used for
- // checking the Split-Horizon
- // flag
+ // Uint64.ONE is used for checking the Split-Horizon flag
+ Uint64 shFlagSet = Uint64.ONE;
List<MatchInfoBase> shMatches = FlowBasedServicesUtils.getMatchInfoForEgressDispatcherTable(interfaceTag,
currentServiceIndex);
shMatches.add(new MatchMetadata(shFlagSet, MetaDataUtil.METADATA_MASK_SH_FLAG));
shFlagSet);
String serviceRef = boundService.getServiceName();
// This must be higher priority than the egress flow
- int splitHorizonFlowPriority = boundService.getServicePriority() + 1;
+ int splitHorizonFlowPriority = boundService.getServicePriority().toJava() + 1;
StypeOpenflow stypeOpenFlow = boundService.augmentation(StypeOpenflow.class);
Flow egressSplitHorizonFlow = MDSALUtil.buildFlow(NwConstants.EGRESS_LPORT_DISPATCHER_TABLE, flowRef,
- splitHorizonFlowPriority, serviceRef, 0, 0, stypeOpenFlow.getFlowCookie(), shMatches, shInstructions);
+ splitHorizonFlowPriority, serviceRef, 0, 0, stypeOpenFlow.getFlowCookie(),
+ shMatches, shInstructions);
installFlow(dpId, egressSplitHorizonFlow, tx);
}
public static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
- BigInteger cookie, List<Instruction> instructions) {
+ Uint64 cookie, List<Instruction> instructions) {
StypeOpenflowBuilder augBuilder = new StypeOpenflowBuilder().setFlowCookie(cookie).setFlowPriority(flowPriority)
.setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority)).setServiceName(serviceName)
IfmUtil.bindService(tx, interfaceName, serviceInfo, ServiceModeEgress.class);
}
- public static void removeIngressFlow(String interfaceName, BigInteger dpId, ManagedNewTransactionRunner txRunner,
+ public static void removeIngressFlow(String interfaceName, Uint64 dpId, ManagedNewTransactionRunner txRunner,
List<ListenableFuture<Void>> futures) {
if (dpId == null) {
return;
}));
}
- public static void removeIngressFlow(String name, BoundServices serviceOld, BigInteger dpId,
+ public static void removeIngressFlow(String name, BoundServices serviceOld, Uint64 dpId,
TypedWriteTransaction<Configuration> writeTransaction) {
String flowKeyStr = getFlowRef(dpId, NwConstants.VLAN_INTERFACE_INGRESS_TABLE, name,
- serviceOld.getServicePriority());
+ serviceOld.getServicePriority().toJava());
LOG.debug("Removing Ingress Flow {}", flowKeyStr);
FlowKey flowKey = new FlowKey(new FlowId(flowKeyStr));
Node nodeDpn = buildInventoryDpnNode(dpId);
writeTransaction.delete(flowInstanceId);
}
- public static void removeLPortDispatcherFlow(BigInteger dpId, String iface, BoundServices boundServicesOld,
+ public static void removeLPortDispatcherFlow(Uint64 dpId, String iface, BoundServices boundServicesOld,
TypedWriteTransaction<Configuration> writeTransaction, short currentServiceIndex) {
LOG.debug("Removing LPort Dispatcher Flows {}, {}", dpId, iface);
EVENT_LOGGER.debug("IFM,removeFlow {}", flowRef);
}
- public static void removeEgressDispatcherFlows(BigInteger dpId, String iface,
+ public static void removeEgressDispatcherFlows(Uint64 dpId, String iface,
TypedWriteTransaction<Configuration> writeTransaction, short currentServiceIndex) {
LOG.debug("Removing Egress Dispatcher Flows {}, {}", dpId, iface);
removeEgressDispatcherFlow(dpId, iface, writeTransaction, currentServiceIndex);
removeEgressSplitHorizonDispatcherFlow(dpId, iface, writeTransaction);
}
- private static void removeEgressDispatcherFlow(BigInteger dpId, String iface,
+ private static void removeEgressDispatcherFlow(Uint64 dpId, String iface,
TypedWriteTransaction<Configuration> writeTransaction, short currentServiceIndex) {
// build the flow and install it
String flowRef = getFlowRef(dpId, NwConstants.EGRESS_LPORT_DISPATCHER_TABLE, iface,
EVENT_LOGGER.debug("IFM,removeFlow {}", flowRef);
}
- public static void removeEgressSplitHorizonDispatcherFlow(BigInteger dpId, String iface,
+ public static void removeEgressSplitHorizonDispatcherFlow(Uint64 dpId, String iface,
TypedWriteTransaction<Configuration> writeTransaction) {
- // BigInteger.ONE is used for checking the Split-Horizon flag
- BigInteger shFlagSet = BigInteger.ONE;
+ // Uint64.ONE is used for checking the Split-Horizon flag
+ Uint64 shFlagSet = Uint64.ONE;
String shFlowRef = getSplitHorizonFlowRef(dpId, NwConstants.EGRESS_LPORT_DISPATCHER_TABLE, iface,
shFlagSet);
FlowKey shFlowKey = new FlowKey(new FlowId(shFlowRef));
writeTransaction.delete(shFlowInstanceId);
}
- public static String getFlowRef(short tableId, BigInteger dpnId, String infName) {
+ public static String getFlowRef(short tableId, Uint64 dpnId, String infName) {
return String.format("%d:%s:%s", tableId, dpnId, infName);
}
- private static String getFlowRef(BigInteger dpnId, short tableId, String iface, short currentServiceIndex) {
+ private static String getFlowRef(Uint64 dpnId, short tableId, String iface, short currentServiceIndex) {
return String.valueOf(dpnId) + NwConstants.FLOWID_SEPARATOR + tableId + NwConstants.FLOWID_SEPARATOR + iface
+ NwConstants.FLOWID_SEPARATOR + currentServiceIndex;
}
- private static String getSplitHorizonFlowRef(BigInteger dpnId, short tableId, String iface, BigInteger shFlag) {
+ private static String getSplitHorizonFlowRef(Uint64 dpnId, short tableId, String iface, Uint64 shFlag) {
return String.valueOf(dpnId) + NwConstants.FLOWID_SEPARATOR + tableId + NwConstants.FLOWID_SEPARATOR + iface
+ NwConstants.FLOWID_SEPARATOR + shFlag.toString();
}
List<BoundServices> availableServiceInfos = new ArrayList<>(serviceInfos);
availableServiceInfos.sort(Comparator.comparing(BoundServices::getServicePriority));
for (BoundServices availableServiceInfo : availableServiceInfos) {
- if (currentServiceInfo.getServicePriority() < availableServiceInfo.getServicePriority()) {
+ if (currentServiceInfo.getServicePriority().toJava() < availableServiceInfo.getServicePriority().toJava()) {
lower = availableServiceInfo;
break;
} else {
BoundServices highPriorityService = availableServiceInfos.get(0);
availableServiceInfos.remove(0);
for (BoundServices availableServiceInfo : availableServiceInfos) {
- if (availableServiceInfo.getServicePriority() < highPriorityService.getServicePriority()) {
+ if (availableServiceInfo.getServicePriority().toJava()
+ < highPriorityService.getServicePriority().toJava()) {
highPriorityService = availableServiceInfo;
}
}
return highPriorityService;
}
- public static void installLportIngressFlow(BigInteger dpId, long portNo, Interface iface,
+ public static void installLportIngressFlow(Uint64 dpId, long portNo, Interface iface,
List<ListenableFuture<Void>> futures, ManagedNewTransactionRunner txRunner, int lportTag) {
int vlanId = 0;
boolean isVlanTransparent = false;
IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
if (l2vlan != null) {
- vlanId = l2vlan.getVlanId() == null ? 0 : l2vlan.getVlanId().getValue();
+ vlanId = l2vlan.getVlanId() == null ? 0 : l2vlan.getVlanId().getValue().toJava();
isVlanTransparent = l2vlan.getL2vlanMode() == IfL2vlan.L2vlanMode.Transparent;
}
int instructionKey = 0;
if (!actions.isEmpty()) {
instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, instructionKey++));
}
- BigInteger metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag, (short) 0, BigInteger.ZERO,
+ Uint64 metadata = MetaDataUtil.getMetaDataForLPortDispatcher(lportTag, (short) 0, Uint64.ZERO,
isExternal(iface));
- BigInteger metadataMask = MetaDataUtil
+ Uint64 metadataMask = MetaDataUtil
.getMetaDataMaskForLPortDispatcher(MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG);
instructions.add(MDSALUtil.buildAndGetWriteMetadaInstruction(metadata, metadataMask, instructionKey++));
instructions
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface
interfaceState, Class<? extends ServiceModeBase> serviceMode) {
NodeConnectorId nodeConnectorId = IfmUtil.getNodeConnectorIdFromInterface(interfaceState);
- BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
long portNo = IfmUtil.getPortNumberFromNodeConnectorId(nodeConnectorId);
BoundServicesStateKey boundServicesStateKey = new BoundServicesStateKey(interfaceState.getName(), serviceMode);
return new BoundServicesStateBuilder().setDpid(dpId).setIfIndex(interfaceState.getIfIndex())
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.interfacemanager.test;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;
-import java.math.BigInteger;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.genius.interfacemanager.IfmUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class IfmUtilTest {
@Test
public void testDpnConversions() {
- String nodeId = IfmUtil.buildDpnNodeId(BigInteger.valueOf(101)).getValue();
+ String nodeId = IfmUtil.buildDpnNodeId(Uint64.valueOf(101)).getValue();
assertEquals("openflow:101", nodeId);
when(ncId.getValue()).thenReturn("openflow:101:11");
- assertEquals(new BigInteger("101"), IfmUtil.getDpnFromNodeConnectorId(ncId));
+ assertEquals(Uint64.valueOf(101), IfmUtil.getDpnFromNodeConnectorId(ncId));
}
}
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.Future;
import javax.inject.Inject;
-
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Component tests for interface manager.
// c) check expected flow entries were created in Interface Ingress
// Table
- BigInteger dpnId = BigInteger.valueOf(1);
+ Uint64 dpnId = Uint64.ONE;
String ingressFlowRef = FlowBasedServicesUtils.getFlowRef(VLAN_INTERFACE_INGRESS_TABLE, dpnId, INTERFACE_NAME);
FlowKey ingressFlowKey = new FlowKey(new FlowId(ingressFlowRef));
Node nodeDpn = InterfaceManagerTestUtil.buildInventoryDpnNode(dpnId);
assertEqualBeans(PARENT_INTERFACE, interfaceInfo.augmentation(ParentRefs.class).getParentInterface());
// 3. fetch dpn-id corresponding to an interface
- BigInteger dpnId = interfaceManager.getDpnForInterface(INTERFACE_NAME);
+ Uint64 dpnId = interfaceManager.getDpnForInterface(INTERFACE_NAME);
Assert.assertEquals(DPN_ID_1, dpnId);
// 4. fetch parent-interface corresponding to an interface
assertEqualBeans(ExpectedInterfaceListFromDpn.checkDpnToInterfaceList(), actualDpnInterfaceList.get(0));
}
- private void createDpnToInterface(BigInteger dpId, String infName,
+ private void createDpnToInterface(Uint64 dpId, String infName,
Class<? extends InterfaceType> interfaceType) throws Exception {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
DpnToInterfaceKey dpnToInterfaceKey = new DpnToInterfaceKey(dpId);
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-
import org.awaitility.core.ConditionTimeoutException;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public static final String TUNNEL_INTERFACE_NAME = "tun414a856a7a4";
public static final String TRUNK_INTERFACE_NAME = "23701c04-7e58-4c65-9425-78a80d49a219";
- public static final BigInteger DPN_ID_1 = BigInteger.valueOf(1);
- public static final BigInteger DPN_ID_2 = BigInteger.valueOf(2);
+ public static final Uint64 DPN_ID_1 = Uint64.ONE;
+ public static final Uint64 DPN_ID_2 = Uint64.valueOf(2);
public static final long PORT_NO_1 = 2;
public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
return ifaceBuilder.build();
}
- static Node buildInventoryDpnNode(BigInteger dpnId) {
+ static Node buildInventoryDpnNode(Uint64 dpnId) {
NodeId nodeId = new NodeId("openflow:" + dpnId);
Node nodeDpn = new NodeBuilder().setId(nodeId).withKey(new NodeKey(nodeId)).build();
return fcNodeConnector.build();
}
- static NodeConnectorId buildNodeConnectorId(BigInteger dpn, long portNo) {
+ static NodeConnectorId buildNodeConnectorId(Uint64 dpn, long portNo) {
return new NodeConnectorId(buildNodeConnectorString(dpn, portNo));
}
- static String buildNodeConnectorString(BigInteger dpn, long portNo) {
+ static String buildNodeConnectorString(Uint64 dpn, long portNo) {
return IfmConstants.OF_URI_PREFIX + dpn + IfmConstants.OF_URI_SEPARATOR + portNo;
}
static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector>
- buildNodeConnectorInstanceIdentifier(BigInteger dpn, long portNo) {
+ buildNodeConnectorInstanceIdentifier(Uint64 dpn, long portNo) {
NodeConnectorId nodeConnectorId = buildNodeConnectorId(dpn, portNo);
NodeId nodeId = IfmUtil.getNodeIdFromNodeConnectorId(nodeConnectorId);
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector>
interfaceInfo = InterfaceManagerTestUtil.buildInterface(ifaceName, ifaceName, true, ifType,
parentRefs.getParentInterface(), IfL2vlan.L2vlanMode.Trunk);
} else {
- interfaceInfo = buildTunnelInterface(parentRefs.getDatapathNodeIdentifier(),ifaceName, ifaceName,
+ interfaceInfo = buildTunnelInterface(parentRefs.getDatapathNodeIdentifier().toJava(),ifaceName, ifaceName,
true, TunnelTypeVxlan.class, "1.1.1.1", "2.2.2.2");
}
InstanceIdentifier<Interface> interfaceInstanceIdentifier = IfmUtil.buildId(ifaceName);
Class<? extends InterfaceType> ifType)
throws TransactionCommitFailedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- BigInteger dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
+ Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, true);
static void updateFlowCapableNodeConnectorState(DataBroker dataBroker, String interfaceName,
Class<? extends InterfaceType> ifType, boolean isLive) throws TransactionCommitFailedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- BigInteger dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
+ Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
NodeConnector nodeConnector = InterfaceManagerTestUtil
.buildFlowCapableNodeConnector(buildNodeConnectorId(dpnId, portNo), interfaceName, isLive);
static void removeFlowCapableNodeConnectorState(DataBroker dataBroker, Class<? extends InterfaceType> ifType)
throws TransactionCommitFailedException {
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
- BigInteger dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
+ Uint64 dpnId = Tunnel.class.equals(ifType) ? DPN_ID_2 : DPN_ID_1;
long portNo = Tunnel.class.equals(ifType) ? PORT_NO_1 : PORT_NO_1;
tx.delete(OPERATIONAL,buildNodeConnectorInstanceIdentifier(dpnId, portNo));
tx.submit().checkedGet();
}
static BoundServices getBoundServices(String serviceName, short servicePriority, int flowPriority,
- BigInteger cookie, List<Instruction> instructions) {
+ Uint64 cookie, List<Instruction> instructions) {
StypeOpenflowBuilder augBuilder = new StypeOpenflowBuilder().setFlowCookie(cookie).setFlowPriority(flowPriority)
.setInstruction(instructions);
return new BoundServicesBuilder().withKey(new BoundServicesKey(servicePriority)).setServiceName(serviceName)
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceOpState
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType
import org.opendaylight.genius.interfacemanager.globals.VlanInterfaceInfo
+import org.opendaylight.yangtools.yang.common.Uint64
class ExpectedInterfaceInfo {
static def newInterfaceInfo(Integer lportTag, String ifaceName, String parentInterface,
InterfaceInfo.InterfaceType ifaceType) {
- new InterfaceInfo(1bi, parentInterface) => [
+ new InterfaceInfo(Uint64.ONE, parentInterface) => [
adminState = InterfaceAdminState.ENABLED
interfaceName = ifaceName
interfaceTag = 1
}
static def newVlanInterfaceInfo() {
- new VlanInterfaceInfo(1bi, "tap23701c04-7e", 0 as short) => [
+ new VlanInterfaceInfo(Uint64.ONE, "tap23701c04-7e", 0 as short) => [
adminState = InterfaceAdminState.ENABLED
interfaceName = "23701c04-7e58-4c65-9425-78a80d49a218"
interfaceTag = 1
package org.opendaylight.genius.interfacemanager.test.xtend
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutputBuilder
+import org.opendaylight.yangtools.yang.common.Uint64
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
static def newPortFromInterfaceOutput() {
new GetPortFromInterfaceOutputBuilder >> [
- dpid = 1bi
+ dpid = Uint64.ONE
phyAddress = "AA:AA:AA:AA:AA:AA"
portname = "23701c04-7e58-4c65-9425-78a80d49a218"
portno = 2L
*/
package org.opendaylight.genius.interfacemanager.shell;
-import java.math.BigInteger;
import java.util.Formatter;
import org.apache.felix.service.command.CommandSession;
import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class IfmCLIUtil {
private static final String VLAN_OUTPUT_FORMAT_LINE1 = "%-55s";
StringBuilder sb = new StringBuilder();
Formatter fmt = new Formatter(sb);
IfL2vlan l2vlan = iface.augmentation(IfL2vlan.class);
- int vlanId = l2vlan != null ? l2vlan.getVlanId() != null ? l2vlan.getVlanId().getValue() : 0 : 0;
+ int vlanId = l2vlan != null ? l2vlan.getVlanId() != null ? l2vlan.getVlanId().getValue().toJava() : 0 : 0;
session.getConsole().println(fmt.format(VLAN_OUTPUT_FORMAT_LINE1,
iface.getName()));
sb.setLength(0);
fmt.close();
}
- static void showBridgePortsHeader(CommandSession session, BigInteger dpnId) {
+ static void showBridgePortsHeader(CommandSession session, Uint64 dpnId) {
StringBuilder sb = new StringBuilder();
Formatter fmt = new Formatter(sb);
session.getConsole().println(fmt
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected Object doExecute() {
LOG.debug("Executing show ovs-ports command");
- List<OvsdbTerminationPointAugmentation> ports = interfaceManager.getPortsOnBridge(dpnId);
+ final Uint64 id = Uint64.valueOf(dpnId);
+ List<OvsdbTerminationPointAugmentation> ports = interfaceManager.getPortsOnBridge(id);
if (!ports.isEmpty()) {
- IfmCLIUtil.showBridgePortsHeader(session, dpnId);
+ IfmCLIUtil.showBridgePortsHeader(session, id);
}
for (OvsdbTerminationPointAugmentation port: ports) {
IfmCLIUtil.showBridgePortsOutput(session, port);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
checksum += getSummation(ip6Hdr.getDestinationIpv6());
checksum = normalizeChecksum(checksum);
- checksum += ip6Hdr.getIpv6Length();
- checksum += ip6Hdr.getNextHeader();
+ checksum += ip6Hdr.getIpv6Length().toJava();
+ checksum += ip6Hdr.getNextHeader().toJava();
int icmp6Offset = Ipv6Constants.ICMPV6_OFFSET;
long value = (packet[icmp6Offset] & 0xff) << 8 | packet[icmp6Offset + 1] & 0xff;
Arrays.fill(data, (byte) 0);
ByteBuffer buf = ByteBuffer.wrap(data);
- long flowLabel = (long) (ip6Pdu.getVersion() & 0x0f) << 28 | ip6Pdu.getFlowLabel() & 0x0fffffff;
+ long flowLabel = (long) (ip6Pdu.getVersion().toJava() & 0x0f) << 28
+ | ip6Pdu.getFlowLabel().toJava() & 0x0fffffff;
buf.putInt((int) flowLabel);
buf.putShort((short) ip6Pdu.getIpv6Length().intValue());
buf.put((byte) ip6Pdu.getNextHeader().shortValue());
naPdu.setTargetAddress(Ipv6Address.getDefaultInstance(
InetAddress.getByAddress(BitBufferHelper.getBits(data, bitOffset, 128)).getHostAddress()));
- if (naPdu.getIpv6Length() > Ipv6Constants.ICMPV6_NA_LENGTH_WO_OPTIONS) {
+ if (naPdu.getIpv6Length().toJava() > Ipv6Constants.ICMPV6_NA_LENGTH_WO_OPTIONS) {
bitOffset = bitOffset + 128;
naPdu.setOptionType(BitBufferHelper.getShort(BitBufferHelper.getBits(data, bitOffset, 8)));
bitOffset = bitOffset + 8;
naPdu.setTargetAddrLength(BitBufferHelper.getShort(BitBufferHelper.getBits(data, bitOffset, 8)));
bitOffset = bitOffset + 8;
- if (naPdu.getOptionType() == Ipv6Constants.ICMP_V6_OPTION_TARGET_LLA) {
+ if (naPdu.getOptionType().toJava() == Ipv6Constants.ICMP_V6_OPTION_TARGET_LLA) {
naPdu.setTargetLlAddress(new MacAddress(
Ipv6Util.bytesToHexString(BitBufferHelper.getBits(data, bitOffset, 48))));
}
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
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.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Ipv6Address srcIpv6Address;
String interfaceName = null;
String macAddr = null;
- BigInteger dpnId;
+ Uint64 dpnId;
int localErrorCount = 0;
targetIpv6Address = ndInput.getTargetIpAddress();
GetPortFromInterfaceOutput portResult = getPortFromInterface(interfaceName);
checkNotNull(portResult);
dpnId = portResult.getDpid();
- Long portid = portResult.getPortno();
- checkArgument(null != dpnId && BigInteger.ZERO != dpnId, DPN_NOT_FOUND_ERROR, interfaceName);
+ Long portid = portResult.getPortno().toJava();
+ checkArgument(null != dpnId && Uint64.ZERO != dpnId, DPN_NOT_FOUND_ERROR, interfaceName);
NodeConnectorRef nodeRef = MDSALUtil.getNodeConnRef(dpnId, portid.toString());
checkNotNull(nodeRef, NODE_CONNECTOR_NOT_FOUND_ERROR, interfaceName);
SendNeighborSolicitationToOfGroupInput ndInput) {
RpcResultBuilder<SendNeighborSolicitationToOfGroupOutput> successBuilder = RpcResultBuilder.success();
ipv6NsHelper.transmitNeighborSolicitationToOfGroup(ndInput.getDpId(), ndInput.getSourceLlAddress(),
- ndInput.getSourceIpv6(), ndInput.getTargetIpAddress(), ndInput.getOfGroupId());
+ ndInput.getSourceIpv6(), ndInput.getTargetIpAddress(), ndInput.getOfGroupId().toJava());
return successBuilder.buildFuture();
}
package org.opendaylight.genius.ipv6util.nd;
-import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
private byte[] fillNeighborSolicitationPacket(NeighborSolicitationPacket pdu) {
- ByteBuffer buf = ByteBuffer.allocate(Ipv6Constants.ICMPV6_OFFSET + pdu.getIpv6Length());
+ ByteBuffer buf = ByteBuffer.allocate(Ipv6Constants.ICMPV6_OFFSET + pdu.getIpv6Length().toJava());
buf.put(Ipv6Util.convertEthernetHeaderToByte(pdu), 0, 14);
buf.put(Ipv6Util.convertIpv6HeaderToByte(pdu), 0, 40);
- buf.put(icmp6NsPayloadtoByte(pdu), 0, pdu.getIpv6Length());
+ buf.put(icmp6NsPayloadtoByte(pdu), 0, pdu.getIpv6Length().toJava());
int checksum = Ipv6Util.calculateIcmpv6Checksum(buf.array(), pdu);
buf.putShort(Ipv6Constants.ICMPV6_OFFSET + 2, (short) checksum);
return buf.array();
}
- public boolean transmitNeighborSolicitation(BigInteger dpnId, NodeConnectorRef nodeRef, MacAddress srcMacAddress,
+ public boolean transmitNeighborSolicitation(Uint64 dpnId, NodeConnectorRef nodeRef, MacAddress srcMacAddress,
Ipv6Address srcIpv6Address, Ipv6Address targetIpv6Address) {
byte[] txPayload = frameNeighborSolicitationRequest(srcMacAddress, srcIpv6Address, targetIpv6Address);
NodeConnectorRef nodeConnectorRef = MDSALUtil.getNodeConnRef(dpnId, "0xfffffffd");
return true;
}
- public void transmitNeighborSolicitationToOfGroup(BigInteger dpId, MacAddress srcMacAddress,
+ public void transmitNeighborSolicitationToOfGroup(Uint64 dpId, MacAddress srcMacAddress,
Ipv6Address srcIpv6Address, Ipv6Address targetIpv6Address, long ofGroupId) {
byte[] txPayload = frameNeighborSolicitationRequest(srcMacAddress, srcIpv6Address, targetIpv6Address);
List<ActionInfo> lstActionInfo = new ArrayList<>();
package org.opendaylight.genius.ipv6util.nd;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class Ipv6NsHelperTest {
private Ipv6NsHelper instance;
doReturn(RpcResultBuilder.status(true).buildFuture()).when(pktProcessService)
.transmitPacket(any(TransmitPacketInput.class));
- BigInteger dpnId = BigInteger.valueOf(1);
+ Uint64 dpnId = Uint64.ONE;
String macAddr = "08:00:27:FE:8F:95";
boolean retValue;
Ipv6Address srcIpv6Address = new Ipv6Address("2001:db8::1");
doReturn(RpcResultBuilder.status(true).buildFuture()).when(pktProcessService)
.transmitPacket(any(TransmitPacketInput.class));
- BigInteger dpnId = BigInteger.valueOf(1);
+ Uint64 dpnId = Uint64.ONE;
String macAddr = "08:00:27:FE:8F:95";
boolean retValue;
Ipv6Address srcIpv6Address = new Ipv6Address("2001:db8::1");
doReturn(RpcResultBuilder.status(true).buildFuture()).when(pktProcessService)
.transmitPacket(any(TransmitPacketInput.class));
- BigInteger dpnId = BigInteger.valueOf(1);
+ Uint64 dpnId = Uint64.ONE;
MacAddress srcMacAddress = new MacAddress("08:00:27:FE:8F:95");
Ipv6Address srcIpv6Address = new Ipv6Address("2001:db8::1");
Ipv6Address targetIpv6Address = new Ipv6Address("2001:db8::2");
doReturn(RpcResultBuilder.status(true).buildFuture()).when(pktProcessService)
.transmitPacket(any(TransmitPacketInput.class));
- BigInteger dpnId = BigInteger.valueOf(1);
+ Uint64 dpnId = Uint64.ONE;
MacAddress srcMacAddress = new MacAddress("08:00:27:FE:8F:95");
Ipv6Address srcIpv6Address = new Ipv6Address("2001:db8::1");
Ipv6Address targetIpv6Address = new Ipv6Address("2001:db8::2");
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
package org.opendaylight.genius.itm.api;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface IITMProvider {
// APIs used by i
- void createLocalCache(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
+ void createLocalCache(Uint64 dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
String gatewayIp, String transportZone);
void commitTeps();
void showCache(String cacheName);
- void deleteVtep(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
+ void deleteVtep(Uint64 dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
String gatewayIp, String transportZone);
void configureTunnelType(String transportZone, String tunnelType);
*/
package org.opendaylight.genius.itm.globals;
-import java.math.BigInteger;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface ITMConstants {
String ITM_SERVICE_NAME = "ITM";
- BigInteger COOKIE_ITM = new BigInteger("9000000", 16);
- BigInteger COOKIE_ITM_EXTERNAL = new BigInteger("9050000", 16);
+ Uint64 COOKIE_ITM = Uint64.valueOf("9000000", 16).intern();
+ Uint64 COOKIE_ITM_EXTERNAL = Uint64.valueOf("9050000", 16).intern();
String ITM_IDPOOL_NAME = "Itmservices";
long ITM_IDPOOL_START = 1L;
*/
package org.opendaylight.genius.itm.utils;
-import java.math.BigInteger;
import org.immutables.value.Value;
import org.opendaylight.genius.infra.OpenDaylightImmutableStyle;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
+import org.opendaylight.yangtools.yang.common.Uint64;
@Value.Immutable
@OpenDaylightImmutableStyle
boolean isInternal();
- BigInteger getRemoteDPN();
+ Uint64 getRemoteDPN();
}
*/
package org.opendaylight.genius.itm.cache;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Check if the destination End Point has come
try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getDstEndPointInfo())) {
Optional<DPNTEPsInfo> dstInfoOpt = getDPNTepFromDPNId(
- new BigInteger(tunnelEndPointInfo.getDstEndPointInfo()));
+ Uint64.valueOf(tunnelEndPointInfo.getDstEndPointInfo()));
if (dstInfoOpt.isPresent()) {
dstDpnTepsInfo = dstInfoOpt.get();
} else {
if (srcDpnTepsInfo == null) {
try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getSrcEndPointInfo())) {
Optional<DPNTEPsInfo> srcInfoOpt = getDPNTepFromDPNId(
- new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo()));
+ Uint64.valueOf(tunnelEndPointInfo.getSrcEndPointInfo()));
if (srcInfoOpt.isPresent()) {
srcDpnTepsInfo = srcInfoOpt.get();
} else {
}
}
- public List<DPNTEPsInfo> getDPNTepListFromDPNId(List<BigInteger> dpnIds) {
+ public List<DPNTEPsInfo> getDPNTepListFromDPNId(List<Uint64> dpnIds) {
Collection<DPNTEPsInfo> meshedDpnList = this.getAllPresent() ;
List<DPNTEPsInfo> cfgDpnList = new ArrayList<>();
- for (BigInteger dpnId : dpnIds) {
+ for (Uint64 dpnId : dpnIds) {
for (DPNTEPsInfo teps : meshedDpnList) {
if (dpnId.equals(teps.getDPNID())) {
cfgDpnList.add(teps);
return cfgDpnList;
}
- public Optional<DPNTEPsInfo> getDPNTepFromDPNId(BigInteger dpnId) {
+ public Optional<DPNTEPsInfo> getDPNTepFromDPNId(Uint64 dpnId) {
Collection<DPNTEPsInfo> meshedDpnList = this.getAllPresent() ;
return meshedDpnList.stream().filter(info -> dpnId.equals(info.getDPNID())).findFirst();
}
*/
package org.opendaylight.genius.itm.cache;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-public class DpnTepStateCache extends DataObjectCache<BigInteger, DpnsTeps> {
+public class DpnTepStateCache extends DataObjectCache<Uint64, DpnsTeps> {
private static final Logger LOG = LoggerFactory.getLogger(DpnTepStateCache.class);
private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
}
private DpnTepInterfaceInfo getDpnTepInterface(String srcDpnId, String dstDpnId) {
- return getDpnTepInterface(new BigInteger(srcDpnId), new BigInteger(dstDpnId));
+ return getDpnTepInterface(Uint64.valueOf(srcDpnId), Uint64.valueOf(dstDpnId));
}
- public DpnTepInterfaceInfo getDpnTepInterface(BigInteger srcDpnId, BigInteger dstDpnId) {
+ public DpnTepInterfaceInfo getDpnTepInterface(Uint64 srcDpnId, Uint64 dstDpnId) {
DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
if (dpnTepInterfaceInfo == null) {
try {
return dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
}
- public void removeTepFromDpnTepInterfaceConfigDS(BigInteger srcDpnId) throws TransactionCommitFailedException {
+ public void removeTepFromDpnTepInterfaceConfigDS(Uint64 srcDpnId) throws TransactionCommitFailedException {
Collection<DpnsTeps> dpnsTeps = this.getAllPresent();
for (DpnsTeps dpnTep : dpnsTeps) {
if (!Objects.equals(dpnTep.getSourceDpnId(), srcDpnId)) {
}
} else {
// The source DPn id is the one to be removed
- InstanceIdentifier<DpnsTeps> dpnsTepsII = buildDpnsTepsInstanceIdentifier(dpnTep.getSourceDpnId());
+ InstanceIdentifier<DpnsTeps> dpnsTepsII
+ = buildDpnsTepsInstanceIdentifier(dpnTep.getSourceDpnId());
SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, dpnsTepsII);
}
}
}
- private InstanceIdentifier<DpnsTeps> buildDpnsTepsInstanceIdentifier(BigInteger srcDpnId) {
+ private static InstanceIdentifier<DpnsTeps> buildDpnsTepsInstanceIdentifier(Uint64 srcDpnId) {
return InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class, new DpnsTepsKey(srcDpnId)).build();
}
- private InstanceIdentifier<RemoteDpns> buildRemoteDpnsInstanceIdentifier(BigInteger srcDpnId, BigInteger dstDpnId) {
+ private static InstanceIdentifier<RemoteDpns> buildRemoteDpnsInstanceIdentifier(Uint64 srcDpnId, Uint64 dstDpnId) {
DpnsTepsKey dpnsTepsKey = new DpnsTepsKey(srcDpnId);
RemoteDpnsKey remoteDpnsKey = new RemoteDpnsKey(dstDpnId);
return InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class, dpnsTepsKey)
return getDpnTepInterface(endPointInfo.getSrcEndPointInfo(), endPointInfo.getDstEndPointInfo());
}
- private String getDpnId(BigInteger src, BigInteger dst) {
+ // FIXME: this seems to be a cache key -- it should use a composite structure rather than string concat
+ private String getDpnId(Uint64 src, Uint64 dst) {
return src + ":" + dst;
}
public Interface getInterfaceFromCache(String tunnelName) {
TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName);
- BigInteger srcDpnId = new BigInteger(endPointInfo.getSrcEndPointInfo());
- BigInteger dstDpnId = new BigInteger(endPointInfo.getDstEndPointInfo());
+ Uint64 srcDpnId = Uint64.valueOf(endPointInfo.getSrcEndPointInfo());
+ Uint64 dstDpnId = Uint64.valueOf(endPointInfo.getDstEndPointInfo());
Interface iface = null ;
int monitoringInt = 1000;
DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(srcDpnId, dstDpnId);
*/
package org.opendaylight.genius.itm.cache;
-import java.math.BigInteger;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Singleton;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
public class OfEndPointCache {
-
private static final Logger LOG = LoggerFactory.getLogger(OfEndPointCache.class);
- private final ConcurrentMap<BigInteger, String> ofEndPtMap =
- new ConcurrentHashMap<>();
+ private final ConcurrentMap<Uint64, String> ofEndPtMap = new ConcurrentHashMap<>();
- public void add(BigInteger dpnId, String ofTunnelName) {
+ public void add(Uint64 dpnId, String ofTunnelName) {
ofEndPtMap.put(dpnId, ofTunnelName);
}
- public String get(BigInteger dpnId) {
+ public String get(Uint64 dpnId) {
return ofEndPtMap.get(dpnId);
}
- public String remove(BigInteger dpnId) {
+ public String remove(Uint64 dpnId) {
return ofEndPtMap.remove(dpnId);
}
- public Set<BigInteger> getAll() {
+ public Set<Uint64> getAll() {
return ofEndPtMap.keySet();
}
}
\ No newline at end of file
*/
package org.opendaylight.genius.itm.cache;
-import java.math.BigInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@Singleton
-public class OvsBridgeEntryCache extends DataObjectCache<BigInteger, OvsBridgeEntry> {
+public class OvsBridgeEntryCache extends DataObjectCache<Uint64, OvsBridgeEntry> {
@Inject
public OvsBridgeEntryCache(DataBroker dataBroker, CacheProvider cacheProvider) {
*/
package org.opendaylight.genius.itm.cache;
-import java.math.BigInteger;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntryKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@Singleton
-public class OvsBridgeRefEntryCache extends DataObjectCache<BigInteger, OvsBridgeRefEntry> {
+public class OvsBridgeRefEntryCache extends DataObjectCache<Uint64, OvsBridgeRefEntry> {
@Inject
public OvsBridgeRefEntryCache(DataBroker dataBroker, CacheProvider cacheProvider) {
* the dpn ids
* @return the list
*/
+ // FIXME: this seems to be completely unused
public static List<BigInteger> constructDpnIdList(final String dpnIds) {
final List<BigInteger> lstDpnIds = new ArrayList<>();
if (StringUtils.isNotBlank(dpnIds)) {
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.genius.itm.api.IITMProvider;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.debug("Executing create TEP command dpnId={}, portName={}, vlanId={}, ipAddress={},"
+ " subnetMask={}, gatewayIp={}, transportZone={}", dpnId, portName, vlanId, ipAddress,
subnetMask, gatewayIp, transportZone);
- itmProvider.createLocalCache(dpnId, portName, vlanId, ipAddress, subnetMask, gatewayIp,
+ itmProvider.createLocalCache(Uint64.valueOf(dpnId), portName, vlanId, ipAddress, subnetMask, gatewayIp,
transportZone);
} catch (Exception e) {
LOG.error("Exception occurred during execution of command \"tep-add\"", e);
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public void createLocalCache(BigInteger dpnId, String ipAddress,
+ public void createLocalCache(Uint64 dpnId, String ipAddress,
String transportZone) throws TepException {
CHECK.incrementAndGet();
}
- public boolean checkTepPerTzPerDpn(String tzone, BigInteger dpnId) {
+ public boolean checkTepPerTzPerDpn(String tzone, Uint64 dpnId) {
// check in local cache
if (transportZonesHashMap.containsKey(tzone)) {
List<Vteps> vtepList = transportZonesHashMap.get(tzone);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- public void deleteVtep(BigInteger dpnId, String ipAddress,
+ public void deleteVtep(Uint64 dpnId, String ipAddress,
String transportZone) throws TepException {
final VtepsKey vtepkey = new VtepsKey(dpnId);
}
// Show DPN-ID and Bridge mapping
- public void showBridges(Map<BigInteger, OvsdbBridgeRef> dpnIdBridgeRefMap) {
+ public void showBridges(Map<Uint64, OvsdbBridgeRef> dpnIdBridgeRefMap) {
System.out.println(String.format("%-16s %-16s %-36s%n", "DPN-ID", "Bridge-Name", "Bridge-UUID")
+ "------------------------------------------------------------------------");
dpnIdBridgeRefMap.forEach((dpnId, ovsdbBridgeRef) -> {
}
// deletes from ADD-cache if it exists.
- public boolean isInCache(BigInteger dpnId, String ipAddress,
+ public boolean isInCache(Uint64 dpnId, String ipAddress,
String transportZone) throws TepException {
boolean exists = false;
final VtepsKey vtepkey = new VtepsKey(dpnId);
tunnelType = StringUtils.upperCase(tunnelType);
tunType = ItmUtils.TUNNEL_TYPE_MAP.get(tunnelType);
- List<TransportZone> tzList = null;
+
InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
Optional<TransportZones> tzones = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
TransportZone tzone = new TransportZoneBuilder().withKey(new TransportZoneKey(transportZoneName))
.setTunnelType(tunType).build();
+ List<TransportZone> tzList = new ArrayList<>();
if (tzones.isPresent()) {
- tzList = tzones.get().getTransportZone();
- if (tzList == null || tzList.isEmpty()) {
- tzList = new ArrayList<>();
+ final List<TransportZone> lst = tzones.get().getTransportZone();
+ if (lst != null) {
+ tzList.addAll(lst);
}
- } else {
- tzList = new ArrayList<>();
}
tzList.add(tzone);
TransportZones transportZones = new TransportZonesBuilder().setTransportZone(tzList).build();
InstanceIdentifier.builder(TunnelMonitorInterval.class).build();
Optional<TunnelMonitorInterval> storedTunnelMonitor = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path,
dataBroker);
- if (!storedTunnelMonitor.isPresent() || storedTunnelMonitor.get().getInterval() != interval) {
+ if (!storedTunnelMonitor.isPresent() || storedTunnelMonitor.get().getInterval().toJava() != interval) {
TunnelMonitorInterval tunnelMonitor = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> tx.merge(path, tunnelMonitor, true)), ItmUtils.DEFAULT_WRITE_CALLBACK,
import org.apache.karaf.shell.commands.Command;
import org.apache.karaf.shell.console.OsgiCommandSupport;
import org.opendaylight.genius.itm.api.IITMProvider;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+ "gatewayIp transportZone");
return null;
}
- itmProvider.deleteVtep(dpnId, portName, vlanId, ipAddress, subnetMask, gatewayIp, transportZone);
+ itmProvider.deleteVtep(Uint64.valueOf(dpnId), portName, vlanId, ipAddress, subnetMask, gatewayIp,
+ transportZone);
LOG.trace("Executing delete TEP command");
return null;
import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.bridge.ref.info.BridgeRefEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.ovs.bridge.ref.info.OvsBridgeRefEntry;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected Object doExecute() {
+ final Uint64 id = dpnId == null ? null : Uint64.valueOf(dpnId);
+
if (interfaceManager.isItmDirectTunnelsEnabled()) {
Collection<OvsBridgeRefEntry> ovsBridgeRefEntries = ovsBridgeRefEntryCache.getAllPresent();
itmProvider.showBridges(ovsBridgeRefEntries.stream()
- .filter(dpnId == null
+ .filter(id == null
? ovsBridgeRefEntry -> true
- : ovsBridgeRefEntry -> ovsBridgeRefEntry.getDpid().equals(dpnId))
+ : ovsBridgeRefEntry -> id.equals(ovsBridgeRefEntry.getDpid()))
.collect(Collectors.toMap(ovsBridgeRefEntry -> ovsBridgeRefEntry.getDpid(),
ovsBridgeRefEntry -> ovsBridgeRefEntry.getOvsBridgeReference())));
} else {
- Map<BigInteger, BridgeRefEntry> bridgeRefEntryMap = interfaceManager.getBridgeRefEntryMap();
+ Map<Uint64, BridgeRefEntry> bridgeRefEntryMap = interfaceManager.getBridgeRefEntryMap();
itmProvider.showBridges(bridgeRefEntryMap.keySet().stream()
- .filter(dpnId == null
+ .filter(id == null
? key -> true
- : key -> key.equals(dpnId))
+ : key -> id.equals(key))
.collect(Collectors.toMap(key -> key,
key -> bridgeRefEntryMap.get(key).getBridgeReference())));
}
*/
package org.opendaylight.genius.itm.confighelpers;
-import static org.opendaylight.genius.infra.Datastore.Configuration;
-
import com.google.common.base.Optional;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
+import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
}
- public void buildTunnelsFromDpnToExternalEndPoint(List<BigInteger> dpnId, IpAddress extIp,
+ public void buildTunnelsFromDpnToExternalEndPoint(List<Uint64> dpnId, IpAddress extIp,
Class<? extends TunnelTypeBase> tunType,
TypedWriteTransaction<Configuration> tx) {
Collection<DPNTEPsInfo> cfgDpnList = dpnId == null ? dpnTEPsInfoCache.getAllPresent()
TransportZone transportZone = transportZoneOptional.get();
//do we need to check tunnel type?
if (transportZone.getDeviceVteps() != null && !transportZone.getDeviceVteps().isEmpty()) {
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
+ : ITMConstants.DUMMY_VLANID;
for (DeviceVteps hwVtepDS : transportZone.getDeviceVteps()) {
//dont mesh if hwVteps and OVS-tep have same ip-address
if (Objects.equals(hwVtepDS.getIpAddress(), tep.getIpAddress())) {
Class<? extends TunnelTypeBase> tunType = TunnelTypeVxlan.class;
if (transportZoneOptional.isPresent()) {
TransportZone tzone = transportZoneOptional.get();
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
//do we need to check tunnel type?
if (tzone.getDeviceVteps() != null && !tzone.getDeviceVteps().isEmpty()) {
for (DeviceVteps hwVtepDS : tzone.getDeviceVteps()) {
}
//for tunnels from OVS
- private boolean wireUp(BigInteger dpnId, String portname, Integer vlanId, IpAddress srcIp, Boolean remoteIpFlow,
+ private boolean wireUp(Uint64 dpnId, String portname, Integer vlanId, IpAddress srcIp, Boolean remoteIpFlow,
String dstNodeId, IpAddress dstIp,
Class<? extends TunnelTypeBase> tunType, Boolean monitorEnabled, Integer monitorInterval,
Class<? extends TunnelMonitoringTypeBase> monitorProtocol,
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
TunnelEndPoints firstEndPt = teps.getTunnelEndPoints().get(0);
// The membership in the listener will always be 1, to get the actual membership
// read from the DS
- List<TzMembership> originalTzMembership = ItmUtils.getOriginalTzMembership(firstEndPt, teps.getDPNID(),
- meshedDpnList);
+ List<TzMembership> originalTzMembership = ItmUtils.getOriginalTzMembership(firstEndPt,
+ teps.getDPNID(), meshedDpnList);
if (originalTzMembership.size() == 1) {
String interfaceName = firstEndPt.getInterfaceName();
String trunkInterfaceName = ItmUtils.getTrunkInterfaceName(interfaceName,
}
if (originalTZone.getVteps() != null) {
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT
: itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
+ : ITMConstants.DUMMY_VLANID;
for (Vteps vtep : originalTZone.getVteps()) {
// TOR-OVS
}
private static void deleteTunnelsInTransportZone(String zoneName, DPNTEPsInfo dpn, TunnelEndPoints srcTep,
- List<HwVtep> cfgdhwVteps, TypedReadWriteTransaction<Configuration> tx)
- throws InterruptedException, ExecutionException {
+ List<HwVtep> cfgdhwVteps, TypedReadWriteTransaction<Configuration> tx)
+ throws InterruptedException, ExecutionException {
InstanceIdentifier<TransportZone> tzonePath = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(zoneName)).build();
Optional<TransportZone> tz = tx.read(tzonePath).get();
}
}
- private static void deleteTrunksOvsTor(BigInteger dpnid, String interfaceName, IpAddress cssIpAddress,
+ private static void deleteTrunksOvsTor(Uint64 dpnid, String interfaceName, IpAddress cssIpAddress,
String topologyId, String nodeId, IpAddress hwIpAddress, Class<? extends TunnelTypeBase> tunType,
TypedReadWriteTransaction<Configuration> tx) throws ExecutionException, InterruptedException {
// OVS-TOR
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (!ItmUtils.getIntersection(srcte.nonnullTzMembership(),
dstte.nonnullTzMembership()).isEmpty()) {
// wire them up
- wireUpBidirectionalTunnel(tx, srcte, dstte, srcDpn.getDPNID(), dstDpn.getDPNID(),
- mdsalManager);
+ wireUpBidirectionalTunnel(tx, srcte, dstte, srcDpn.getDPNID(), dstDpn.getDPNID(), mdsalManager);
if (!ItmTunnelAggregationHelper.isTunnelAggregationEnabled()) {
// CHECK THIS -- Assumption -- One end point per Dpn per transport zone
break;
}
private void wireUpBidirectionalTunnel(TypedReadWriteTransaction<Configuration> tx, TunnelEndPoints srcte,
- TunnelEndPoints dstte, BigInteger srcDpnId, BigInteger dstDpnId, IMdsalApiManager mdsalManager)
- throws ExecutionException, InterruptedException, OperationFailedException {
+ TunnelEndPoints dstte, Uint64 srcDpnId, Uint64 dstDpnId, IMdsalApiManager mdsalManager)
+ throws ExecutionException, InterruptedException, OperationFailedException {
// Setup the flow for LLDP monitoring -- PUNT TO CONTROLLER
if (monitorProtocol.isAssignableFrom(TunnelMonitoringTypeLldp.class)) {
}
private boolean wireUp(TypedWriteTransaction<Configuration> tx, TunnelEndPoints srcte, TunnelEndPoints dstte,
- BigInteger srcDpnId, BigInteger dstDpnId)
- throws ExecutionException, InterruptedException, OperationFailedException {
+ Uint64 srcDpnId, Uint64 dstDpnId)
+ throws ExecutionException, InterruptedException, OperationFailedException {
// Wire Up logic
LOG.trace("Wiring between source tunnel end points {}, destination tunnel end points {}", srcte, dstte);
String interfaceName = srcte.getInterfaceName();
return true;
}
- private void createTunnelInterface(TunnelEndPoints srcte, TunnelEndPoints dstte, BigInteger srcDpnId,
+ private void createTunnelInterface(TunnelEndPoints srcte, TunnelEndPoints dstte, Uint64 srcDpnId,
Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName, String parentInterfaceName) {
String gateway = srcte.getIpAddress().getIpv4Address() != null ? "0.0.0.0" : "::";
IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance(gateway);
ItmUtils.ITM_CACHE.addInterface(iface);
}
- private static void createLogicalTunnelInterface(BigInteger srcDpnId,
- Class<? extends TunnelTypeBase> tunType, String interfaceName) {
- Interface iface = ItmUtils.buildLogicalTunnelInterface(srcDpnId, interfaceName,
- String.format("%s %s",ItmUtils.convertTunnelTypetoString(tunType), "Interface"), true);
- InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(interfaceName);
- ITMBatchingUtils.update(trunkIdentifier, iface, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
- ItmUtils.ITM_CACHE.addInterface(iface);
- }
-
- private static void createInternalTunnel(TypedWriteTransaction<Configuration> tx, BigInteger srcDpnId,
- BigInteger dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName) {
+ private static void createInternalTunnel(TypedWriteTransaction<Configuration> tx, Uint64 srcDpnId,
+ Uint64 dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName) {
InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(TunnelList.class)
.child(InternalTunnel.class, new InternalTunnelKey(dstDpnId, srcDpnId, tunType));
InternalTunnel tnl = ItmUtils.buildInternalTunnel(srcDpnId, dstDpnId, tunType, trunkInterfaceName);
ItmUtils.ITM_CACHE.addInternalTunnel(tnl);
}
- private String createLogicalGroupTunnel(BigInteger srcDpnId, BigInteger dstDpnId) {
+ private String createLogicalGroupTunnel(Uint64 srcDpnId, Uint64 dstDpnId) {
boolean tunnelAggregationEnabled = ItmTunnelAggregationHelper.isTunnelAggregationEnabled();
if (!tunnelAggregationEnabled) {
return null;
private static class ItmTunnelAggregationWorker implements Callable<List<ListenableFuture<Void>>> {
private final String logicTunnelGroupName;
- private final BigInteger srcDpnId;
- private final BigInteger dstDpnId;
+ private final Uint64 srcDpnId;
+ private final Uint64 dstDpnId;
private final ManagedNewTransactionRunner txRunner;
- ItmTunnelAggregationWorker(String logicGroupName, BigInteger srcDpnId, BigInteger dstDpnId, DataBroker broker) {
+ ItmTunnelAggregationWorker(String logicGroupName, Uint64 srcDpnId, Uint64 dstDpnId, DataBroker broker) {
this.logicTunnelGroupName = logicGroupName;
this.srcDpnId = srcDpnId;
this.dstDpnId = dstDpnId;
}
}));
}
+
+ private static void createLogicalTunnelInterface(Uint64 srcDpnId,
+ Class<? extends TunnelTypeBase> tunType, String interfaceName) {
+ Interface iface = ItmUtils.buildLogicalTunnelInterface(srcDpnId, interfaceName,
+ String.format("%s %s",ItmUtils.convertTunnelTypetoString(tunType), "Interface"), true);
+ InstanceIdentifier<Interface> trunkIdentifier = ItmUtils.buildId(interfaceName);
+ ITMBatchingUtils.update(trunkIdentifier, iface, ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
+ ItmUtils.ITM_CACHE.addInterface(iface);
+ }
}
- private void createInternalDirectTunnels(TunnelEndPoints srcte, TunnelEndPoints dstte, BigInteger srcDpnId,
- BigInteger dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName,
- String parentInterfaceName) throws OperationFailedException {
+ private void createInternalDirectTunnels(TunnelEndPoints srcte, TunnelEndPoints dstte, Uint64 srcDpnId,
+ Uint64 dstDpnId, Class<? extends TunnelTypeBase> tunType, String trunkInterfaceName,
+ String parentInterfaceName) throws OperationFailedException {
IpAddress gatewayIpObj = IpAddressBuilder.getDefaultInstance("0.0.0.0");
IpAddress gwyIpAddress = gatewayIpObj;
LOG.debug("Creating Trunk Interface with parameters trunk I/f Name - {}, parent I/f name - {}, source IP - {},"
dpnsTepsBuilder.setSourceDpnId(srcDpnId);
if (useOfTunnel) {
String tunnelType = ItmUtils.convertTunnelTypetoString(srcte.getTunnelType());
- ofTunnelPortName = directTunnelUtils.generateOfPortName(srcDpnId, tunnelType);
+ ofTunnelPortName = DirectTunnelUtils.generateOfPortName(srcDpnId, tunnelType);
dpnsTepsBuilder.setOfTunnel(ofTunnelPortName);
}
RemoteDpnsBuilder remoteDpn = new RemoteDpnsBuilder();
return;
}
- BigInteger dpId = parentRefs.getDatapathNodeIdentifier();
+ Uint64 dpId = parentRefs.getDatapathNodeIdentifier();
if (dpId == null) {
LOG.warn("dpid for interface: {} Not Found. No DPID provided. Creation of OF-Port not supported.",
iface.getName());
}
}
- private boolean createTunnelPort(BigInteger dpId) {
+ private boolean createTunnelPort(Uint64 dpId) {
if (!itmCfg.isUseOfTunnels()) {
return true;
}
- return (ofEndPointCache.get(dpId) == null);
+ return ofEndPointCache.get(dpId) == null;
}
private void addPortToBridgeOnCallback(Interface iface, String portName, OvsBridgeRefEntry bridgeRefEntry) {
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
} else {
if (checkIfTrunkExists(dstDpn.getDPNID(), srcDpn.getDPNID(),
- srcTep.getTunnelType(), dataBroker)) {
+ srcTep.getTunnelType(), dataBroker)) {
// remove all trunk interfaces
LOG.trace("Invoking removeTrunkInterface between source TEP {} , "
+ "Destination TEP {} ", srcTep, dstTep);
}
private void removeTrunkInterface(TypedWriteTransaction<Configuration> tx, TunnelEndPoints srcTep,
- TunnelEndPoints dstTep, BigInteger srcDpnId, BigInteger dstDpnId) {
+ TunnelEndPoints dstTep, Uint64 srcDpnId, Uint64 dstDpnId) {
String trunkfwdIfName = ItmUtils.getTrunkInterfaceName(srcTep.getInterfaceName(),
srcTep.getIpAddress().stringValue(),
dstTep.getIpAddress().stringValue(),
removeLogicalGroupTunnel(dstDpnId, srcDpnId);
}
- private static boolean checkIfTrunkExists(BigInteger srcDpnId, BigInteger dstDpnId,
+ private static boolean checkIfTrunkExists(Uint64 srcDpnId, Uint64 dstDpnId,
Class<? extends TunnelTypeBase> tunType, DataBroker dataBroker) {
InstanceIdentifier<InternalTunnel> path = InstanceIdentifier.create(TunnelList.class)
.child(InternalTunnel.class, new InternalTunnelKey(dstDpnId, srcDpnId, tunType));
return ItmUtils.read(LogicalDatastoreType.CONFIGURATION,path, dataBroker).isPresent();
}
- private void removeLogicalGroupTunnel(BigInteger srcDpnId, BigInteger dstDpnId) {
+ private void removeLogicalGroupTunnel(Uint64 srcDpnId, Uint64 dstDpnId) {
boolean tunnelAggregationEnabled = ItmTunnelAggregationHelper.isTunnelAggregationEnabled();
if (!tunnelAggregationEnabled) {
return;
private static class ItmTunnelAggregationDeleteWorker implements Callable<List<ListenableFuture<Void>>> {
private final String logicTunnelName;
- private final BigInteger srcDpnId;
- private final BigInteger dstDpnId;
+ private final Uint64 srcDpnId;
+ private final Uint64 dstDpnId;
private final ManagedNewTransactionRunner txRunner;
- ItmTunnelAggregationDeleteWorker(String groupName, BigInteger srcDpnId, BigInteger dstDpnId, DataBroker db) {
+ ItmTunnelAggregationDeleteWorker(String groupName, Uint64 srcDpnId, Uint64 dstDpnId, DataBroker db) {
this.logicTunnelName = groupName;
this.srcDpnId = srcDpnId;
this.dstDpnId = dstDpnId;
}
private void removeTunnelInterfaceFromOvsdb(TypedReadWriteTransaction<Configuration> tx, TunnelEndPoints srcTep,
- TunnelEndPoints dstTep, BigInteger srcDpnId, BigInteger dstDpnId) {
+ TunnelEndPoints dstTep, Uint64 srcDpnId, Uint64 dstDpnId) {
String trunkfwdIfName = ItmUtils.getTrunkInterfaceName(srcTep.getInterfaceName(),
srcTep.getIpAddress().getIpv4Address().getValue(),
dstTep.getIpAddress().getIpv4Address().getValue(),
}
}
- private boolean checkIfTepInterfaceExists(BigInteger srcDpnId, BigInteger dstDpnId) {
- DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepStateCache.getDpnTepInterface(srcDpnId,dstDpnId);
+ private boolean checkIfTepInterfaceExists(Uint64 srcDpnId, Uint64 dstDpnId) {
+ DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepStateCache.getDpnTepInterface(srcDpnId, dstDpnId);
if (dpnTepInterfaceInfo != null) {
return dpnTepInterfaceInfo.getTunnelName() != null;
}
}
private void removeConfiguration(TypedReadWriteTransaction<Configuration> tx, Interface interfaceOld,
- ParentRefs parentRefs) throws ExecutionException, InterruptedException, OperationFailedException {
+ ParentRefs parentRefs) throws ExecutionException, InterruptedException, OperationFailedException {
IfTunnel ifTunnel = interfaceOld.augmentation(IfTunnel.class);
if (ifTunnel != null) {
// Check if the same transaction can be used across Config and operational shards
throws ExecutionException, InterruptedException, OperationFailedException {
LOG.info("removing tunnel configuration for {}", interfaceName);
- BigInteger dpId = null;
+ Uint64 dpId = null;
if (parentRefs != null) {
dpId = parentRefs.getDatapathNodeIdentifier();
}
directTunnelUtils.removeLportTagInterfaceMap(interfaceName);
}
- private OvsdbBridgeRef getOvsdbBridgeRef(BigInteger dpId) throws ReadFailedException {
+ private OvsdbBridgeRef getOvsdbBridgeRef(Uint64 dpId) throws ReadFailedException {
Optional<OvsBridgeRefEntry> ovsBridgeRefEntryOptional = ovsBridgeRefEntryCache.get(dpId);
Optional<OvsBridgeEntry> ovsBridgeEntryOptional;
OvsdbBridgeRef ovsdbBridgeRef = null;
}
private void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> tx, String interfaceName,
- BigInteger dpId) throws ExecutionException, InterruptedException {
+ Uint64 dpId) throws ExecutionException, InterruptedException {
directTunnelUtils.removeTunnelIngressFlow(tx, dpId, interfaceName);
}
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpnsBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
remoteDpnTepNewList.add(remoteDpnNew);
LOG.debug("toggleMonitoring: RemoteDpnNew {}", remoteDpnNew);
- directTunnelUtils.updateBfdConfiguration(dpnTeps.getSourceDpnId(), remoteDpnNew, ovsBridgeRefEntry);
+ directTunnelUtils.updateBfdConfiguration(dpnTeps.getSourceDpnId(),
+ remoteDpnNew, ovsBridgeRefEntry);
}
updateMonitoringDS(dpnTeps.getSourceDpnId(), remoteDpnTepNewList, tx);
}
- public void updateMonitoringDS(BigInteger sourceDpnId,List<RemoteDpns> remoteDpnTepNewList,
+ public void updateMonitoringDS(Uint64 sourceDpnId, List<RemoteDpns> remoteDpnTepNewList,
TypedWriteTransaction<Datastore.Configuration> tx) {
InstanceIdentifier<DpnsTeps> iid = DirectTunnelUtils.createDpnTepsInstanceIdentifier(sourceDpnId);
DpnsTepsBuilder builder = new DpnsTepsBuilder().withKey(new DpnsTepsKey(sourceDpnId))
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Move TEP from TepsNotHosted list to NBI configured TZ.
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore
.CONFIGURATION, tx -> OvsdbTepAddConfigHelper.addVtepInITMConfigDS(
- vtepsList, null /*tepIpAddress*/, tzName, BigInteger.ZERO,
+ vtepsList, null /*tepIpAddress*/, tzName, Uint64.ZERO,
false, tx)));
}
}
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import org.opendaylight.genius.infra.Datastore;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final IpAddress tepIpAddress;
private final String tzName;
- private final BigInteger dpnId;
+ private final Uint64 dpnId;
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
- public ItmTepsNotHostedRemoveWorker(String tzName, IpAddress tepIpAddress, BigInteger dpnId, DataBroker broker,
+ public ItmTepsNotHostedRemoveWorker(String tzName, IpAddress tepIpAddress, Uint64 dpnId, DataBroker broker,
ManagedNewTransactionRunner txRunner) {
this.tepIpAddress = tepIpAddress;
this.tzName = tzName;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
public void createLogicalTunnelSelectGroup(TypedWriteTransaction<Configuration> tx,
- BigInteger srcDpnId, String interfaceName, int lportTag) {
+ Uint64 srcDpnId, String interfaceName, int lportTag) {
Group group = prepareLogicalTunnelSelectGroup(interfaceName, lportTag);
LOG.debug("MULTIPLE_VxLAN_TUNNELS: group id {} installed for {} srcDpnId {}",
group.getGroupId().getValue(), interfaceName, srcDpnId);
if (listActionInfo.isEmpty()) {
LOG.warn("MULTIPLE_VxLAN_TUNNELS: could not build Egress bucket for {}", interfaceName);
}
- Integer portWeight = ifTunnel.getWeight() != null ? ifTunnel.getWeight() : DEFAULT_WEIGHT;
+ Integer portWeight = ifTunnel.getWeight() != null ? ifTunnel.getWeight().toJava() : DEFAULT_WEIGHT;
return MDSALUtil.buildBucket(MDSALUtil.buildActions(listActionInfo), portWeight, bucketId,
portNumber, MDSALUtil.WATCH_GROUP);
}
- private void updateTunnelAggregationGroup(
- TypedWriteTransaction<Configuration> tx,
- InterfaceParentEntry parentEntry) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private void updateTunnelAggregationGroup(TypedWriteTransaction<Configuration> tx,
+ InterfaceParentEntry parentEntry) {
String logicTunnelName = parentEntry.getParentInterface();
InternalTunnel logicInternalTunnel = ItmUtils.ITM_CACHE.getInternalTunnel(logicTunnelName);
if (logicInternalTunnel == null) {
InterfaceInfo ifLogicTunnel = interfaceManager.getInterfaceInfoFromOperationalDataStore(logicTunnelName);
long groupId = ifLogicTunnel != null
? interfaceManager.getLogicalTunnelSelectGroupId(ifLogicTunnel.getInterfaceTag()) : INVALID_ID;
- BigInteger srcDpnId = logicInternalTunnel.getSourceDPN();
+ Uint64 srcDpnId = logicInternalTunnel.getSourceDPN();
List<Bucket> listBuckets = new ArrayList<>();
List<InterfaceChildEntry> interfaceChildEntries = parentEntry.getInterfaceChildEntry();
if (interfaceChildEntries == null || interfaceChildEntries.isEmpty()) {
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void updateTunnelAggregationGroupBucket(Interface ifaceState, IfTunnel ifTunnel,
ParentRefs parentRefs, InterfaceParentEntry groupParentEntry,
int action, TypedReadWriteTransaction<Configuration> tx)
}
String lowerLayerIf = ifaceState.getLowerLayerIf().get(0); // openflow:dpnid:portnum
String[] split = lowerLayerIf.split(IfmConstants.OF_URI_SEPARATOR);
- BigInteger srcDpnId = new BigInteger(split[1]);
+ Uint64 srcDpnId = Uint64.valueOf(split[1]);
int portNumber = Integer.parseInt(split[2]);
if (action == ADD_TUNNEL) {
if (!mdsalManager.groupExists(srcDpnId, groupId)) {
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void updateLogicalTunnelGroupOperStatus(String logicalTunnelIfaceName, Interface ifaceState,
InterfaceParentEntry parentEntry, TypedReadWriteTransaction<Operational> tx)
throws ExecutionException, InterruptedException {
tx.merge(idLogicGroup, ifaceBuilderChild.build(), CREATE_MISSING_PARENTS);
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void updateLogicalTunnelAdminStatus(String logicalTunnelName, Interface ifOrigin,
Interface ifUpdated, InterfaceParentEntry parentEntry, TypedWriteTransaction<Operational> tx) {
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void updateInterfaceAdminStatus(String logicalTunnelName, Interface ifState,
TypedWriteTransaction<Operational> tx) {
InterfaceInfo ifLogicTunnelInfo = interfaceManager.getInterfaceInfoFromOperationalDataStore(logicalTunnelName);
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
boolean ofTunnel, DataBroker dataBroker,
ManagedNewTransactionRunner txRunner) {
List<ListenableFuture<Void>> futures = new ArrayList<>();
- BigInteger dpnId = BigInteger.valueOf(0);
+ Uint64 dpnId = Uint64.ZERO;
if (strDpnId != null && !strDpnId.isEmpty()) {
dpnId = MDSALUtil.getDpnId(strDpnId);
}
- final BigInteger id = dpnId;
+ final Uint64 id = dpnId;
final String name = tzName;
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> addConfig(name, id, tepIpAddress, ofTunnel, tx)));
* @param updatedVtepList updated Vteps list object which will have new TEP for addition
* @param tepIpAddress TEP IP address in IpAddress object
* @param tzName transport zone name in string
- * @param dpid bridge datapath ID in BigInteger
+ * @param dpid bridge datapath ID
* @param ofTunnel boolean flag for TEP to enable/disable of-tunnel feature on it
* @param tx TypedWriteTransaction object
*/
public static void addVtepInITMConfigDS(List<Vteps> updatedVtepList, IpAddress tepIpAddress, String tzName,
- BigInteger dpid, boolean ofTunnel,
+ Uint64 dpid, boolean ofTunnel,
TypedWriteTransaction<Datastore.Configuration> tx) {
//Create TZ node path
InstanceIdentifier<TransportZone> tranzportZonePath =
// this check is needed to reuse same function from TransportZoneListener
// when VTEP is moved from TepsNotHosted list to TZ configured from Northbound.
- if (dpid.compareTo(BigInteger.ZERO) > 0) {
+ if (dpid.compareTo(Uint64.ZERO) > 0) {
// create vtep
VtepsKey vtepkey = new VtepsKey(dpid);
Vteps vtepObj =
*
* @param tzName transport zone name in string
* @param tepIpAddress TEP IP address in IpAddress object
- * @param dpid bridge datapath ID in BigInteger
+ * @param dpid bridge datapath ID
* @param ofTunnel boolean flag for TEP to enable/disable of-tunnel feature on it
* @param dataBroker data broker handle to perform operations on operational datastore
* @param tx TypedWriteTransaction object
*/
protected static void addUnknownTzTepIntoTepsNotHosted(String tzName, IpAddress tepIpAddress,
- BigInteger dpid, boolean ofTunnel, DataBroker dataBroker,
+ Uint64 dpid, boolean ofTunnel, DataBroker dataBroker,
TypedWriteTransaction<Datastore.Operational> tx) {
List<UnknownVteps> vtepList;
TepsInNotHostedTransportZone tepsInNotHostedTransportZone =
tx.merge(tepsInNotHostedTransportZoneIid, updatedTzone, true);
}
- private static void addConfig(String tzName, BigInteger dpnId, IpAddress ipAdd,
+ private static void addConfig(String tzName, Uint64 dpnId, IpAddress ipAdd,
boolean ofTunnel, TypedWriteTransaction<Datastore.Configuration> tx) {
List<Vteps> vtepList = new ArrayList<>();
}
private static List<ListenableFuture<Void>> addUnknownTzTepIntoTepsNotHostedAndReturnFutures(String tzName,
- IpAddress tepIpAddress, BigInteger id, boolean ofTunnel,
+ IpAddress tepIpAddress, Uint64 id, boolean ofTunnel,
DataBroker dataBroker, ManagedNewTransactionRunner txRunner) {
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL,
tx -> addUnknownTzTepIntoTepsNotHosted(tzName, tepIpAddress, id, ofTunnel, dataBroker, tx)));
}
private static List<UnknownVteps> addVtepToUnknownVtepsList(List<UnknownVteps> updatedVtepList,
- IpAddress tepIpAddress, BigInteger dpid,
+ IpAddress tepIpAddress, Uint64 dpid,
boolean ofTunnel) {
// create vtep
UnknownVtepsKey vtepkey = new UnknownVtepsKey(dpid);
package org.opendaylight.genius.itm.confighelpers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
DataBroker dataBroker,
ManagedNewTransactionRunner txRunner) {
List<ListenableFuture<Void>> futures = new ArrayList<>();
- BigInteger dpnId = BigInteger.ZERO;
+ Uint64 dpnId = Uint64.ZERO;
LOG.trace("Remove TEP: TEP-IP: {}, TZ name: {}, DPID: {}", tepIp, tzName, strDpnId);
if (strDpnId != null && !strDpnId.isEmpty()) {
// Case: Add TEP into corresponding TZ created from Northbound.
transportZone = ItmUtils.getTransportZoneFromConfigDS(tzName, dataBroker);
String name = tzName;
- BigInteger id = dpnId;
+ Uint64 id = dpnId;
if (transportZone == null) {
// Case: TZ is not configured from Northbound, then add TEP into
// "teps-in-not-hosted-transport-zone"
LOG.trace("Remove TEP from vtep list in subnet list of transport-zone.");
dpnId = oldVtep.getDpnId();
String name = tzName;
- BigInteger id = dpnId;
+ Uint64 id = dpnId;
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> removeVtepFromTZConfig(name, id, tx)));
} else {
* Removes the TEP from subnet list in the transport zone list
* from ITM configuration Datastore by delete operation with write transaction.
*
- * @param dpnId bridge datapath ID in BigInteger
+ * @param dpnId bridge datapath ID
* @param tzName transport zone name in string
* @param tx TypedWriteTransaction object
*/
- private static void removeVtepFromTZConfig(String tzName, BigInteger dpnId,
+ private static void removeVtepFromTZConfig(String tzName, Uint64 dpnId,
TypedWriteTransaction<Datastore.Configuration> tx) {
VtepsKey vtepkey = new VtepsKey(dpnId);
*
* @param tzName transport zone name in string
* @param tepIpAddress TEP IP address in IpAddress object
- * @param dpnId bridge datapath ID in BigInteger
+ * @param dpnId bridge datapath ID
* @param dataBroker data broker handle to perform operations on operational datastore
* @param tx TypedWriteTransaction object
*/
public static void removeUnknownTzTepFromTepsNotHosted(String tzName, IpAddress tepIpAddress,
- BigInteger dpnId, DataBroker dataBroker,
+ Uint64 dpnId, DataBroker dataBroker,
TypedWriteTransaction<Datastore.Operational> tx) {
List<UnknownVteps> vtepList;
TepsInNotHostedTransportZone tepsInNotHostedTransportZone =
} else {
// case: vtep list has elements
boolean vtepFound = false;
- UnknownVteps foundVtep = null;
for (UnknownVteps vtep : vtepList) {
if (Objects.equals(vtep.getDpnId(), dpnId)) {
vtepFound = true;
- foundVtep = vtep;
break;
}
}
} else {
removeVtepFromTepsNotHosted(tzName, dpnId, tx);
}
- vtepList.remove(foundVtep);
}
}
}
* from ITM operational Datastore by delete operation with write transaction.
*
* @param tzName transport zone name in string
- * @param dpnId bridge datapath ID in BigInteger
+ * @param dpnId bridge datapath ID
* @param tx TypedWriteTransaction object
*/
- private static void removeVtepFromTepsNotHosted(String tzName, BigInteger dpnId,
+ private static void removeVtepFromTepsNotHosted(String tzName, Uint64 dpnId,
TypedWriteTransaction<Datastore.Operational> tx) {
InstanceIdentifier<UnknownVteps> vtepPath = InstanceIdentifier.builder(NotHostedTransportZones.class)
.child(TepsInNotHostedTransportZone.class, new TepsInNotHostedTransportZoneKey(tzName))
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
batchSize = ITMConstants.BATCH_SIZE;
LOG.info("entered initialse");
if (itmConfig.getBatchSize() != null) {
- batchSize = itmConfig.getBatchSize();
+ batchSize = itmConfig.getBatchSize().toJava();
}
batchInterval = ITMConstants.PERIODICITY;
if (itmConfig.getBatchInterval() != null) {
- batchInterval = itmConfig.getBatchInterval();
+ batchInterval = itmConfig.getBatchInterval().toJava();
}
ITMBatchingUtils.registerWithBatchManager(this.dataBroker,this.batchSize,this.batchInterval);
}
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
.setPoolName(ITMConstants.ITM_IDPOOL_NAME)
.setLow(ITMConstants.ITM_IDPOOL_START)
- .setHigh(new BigInteger(ITMConstants.ITM_IDPOOL_SIZE).longValue())
+ .setHigh(Uint32.valueOf(ITMConstants.ITM_IDPOOL_SIZE))
.build();
try {
ListenableFuture<RpcResult<CreateIdPoolOutput>> result = idManager.createIdPool(createPool);
}
@Override
- public void createLocalCache(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
- String gatewayIp, String transportZone) {
+ public void createLocalCache(Uint64 dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
+ String gatewayIp, String transportZone) {
if (tepCommandHelper != null) {
try {
tepCommandHelper.createLocalCache(dpnId, ipAddress, transportZone);
}
@Override
- public void deleteVtep(BigInteger dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
- String gatewayIp, String transportZone) {
+ public void deleteVtep(Uint64 dpnId, String portName, Integer vlanId, String ipAddress, String subnetMask,
+ String gatewayIp, String transportZone) {
try {
tepCommandHelper.deleteVtep(dpnId, ipAddress, transportZone);
} catch (TepException e) {
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
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.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final BiMap<String,Class<? extends TunnelTypeBase>> STRING_CLASS_IMMUTABLE_BI_MAP =
ImmutableBiMap.copyOf(TUNNEL_TYPE_MAP);
+ private static final Uint64 COOKIE_ITM_LLD = Uint64.fromLongBits(
+ ITMConstants.COOKIE_ITM.longValue() + ITMConstants.LLDP_SERVICE_ID).intern();
private ItmUtils() {
}
- public static final FutureCallback<Void> DEFAULT_WRITE_CALLBACK = new FutureCallback<Void>() {
+ public static final FutureCallback<Void> DEFAULT_WRITE_CALLBACK = new FutureCallback<>() {
@Override
public void onSuccess(Void result) {
LOG.debug("Success in Datastore write operation");
}
@Override
- public void onFailure(@NonNull Throwable error) {
+ public void onFailure(Throwable error) {
LOG.error("Error in Datastore write operation", error);
}
};
//ITM cleanup:portname and vlanId are removed, causes change in generated
//interface name: This has upgrade impact
- public static String getInterfaceName(final BigInteger datapathid, final String portName, final Integer vlanId) {
+ public static String getInterfaceName(final Uint64 datapathid, final String portName, final Integer vlanId) {
return String.format("%s:%s:%s", datapathid, portName, vlanId);
}
LOG.trace("Releasing Id for trunkInterface - {}", trunkInterfaceName);
}
- public static String getLogicalTunnelGroupName(BigInteger srcDpnId, BigInteger destDpnId) {
+ public static String getLogicalTunnelGroupName(Uint64 srcDpnId, Uint64 destDpnId) {
String tunnelTypeStr = ITMConstants.TUNNEL_TYPE_LOGICAL_GROUP_VXLAN;
String groupName = String.format("%s:%s:%s", srcDpnId.toString(), destDpnId.toString(), tunnelTypeStr);
LOG.trace("logical tunnel group name is {}", groupName);
return IetfInetUtil.INSTANCE.inetAddressFor(ip);
}
- public static InstanceIdentifier<DPNTEPsInfo> getDpnTepInstance(BigInteger dpIdKey) {
+ public static InstanceIdentifier<DPNTEPsInfo> getDpnTepInstance(Uint64 dpIdKey) {
return InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class, new DPNTEPsInfoKey(dpIdKey))
.build();
}
- public static DPNTEPsInfo createDPNTepInfo(BigInteger dpId, List<TunnelEndPoints> endpoints) {
+ public static DPNTEPsInfo createDPNTepInfo(Uint64 dpId, List<TunnelEndPoints> endpoints) {
return new DPNTEPsInfoBuilder().withKey(new DPNTEPsInfoKey(dpId)).setTunnelEndPoints(endpoints).build();
}
- public static TunnelEndPoints createTunnelEndPoints(BigInteger dpnId, IpAddress ipAddress, String portName,
+ public static TunnelEndPoints createTunnelEndPoints(Uint64 dpnId, IpAddress ipAddress, String portName,
boolean isOfTunnel, int vlanId, List<TzMembership> zones,
Class<? extends TunnelTypeBase> tunnelType,
String tos) {
.build();
}
- public static TunnelEndPoints createDummyTunnelEndPoints(BigInteger dpnID, IpAddress ipAddress, boolean ofTunnel,
+ public static TunnelEndPoints createDummyTunnelEndPoints(Uint64 dpnID, IpAddress ipAddress, boolean ofTunnel,
String tos, List<TzMembership> zones,
Class<? extends TunnelTypeBase> tunnelType,
String port, int vlanID) {
.child(Interface.class, new InterfaceKey(ifName)).augmentation(IfTunnel.class).build();
}
- public static Interface buildLogicalTunnelInterface(BigInteger dpn, String ifName, String desc, boolean enabled) {
+ public static Interface buildLogicalTunnelInterface(Uint64 dpn, String ifName, String desc, boolean enabled) {
InterfaceBuilder builder = new InterfaceBuilder().withKey(new InterfaceKey(ifName)).setName(ifName)
.setDescription(desc).setEnabled(enabled).setType(Tunnel.class);
ParentRefs parentRefs = new ParentRefsBuilder().setDatapathNodeIdentifier(dpn).build();
return builder.build();
}
- public static Interface buildTunnelInterface(BigInteger dpn, String ifName, String desc, boolean enabled,
+ public static Interface buildTunnelInterface(Uint64 dpn, String ifName, String desc, boolean enabled,
Class<? extends TunnelTypeBase> tunType, IpAddress localIp,
IpAddress remoteIp, boolean internal,
Boolean monitorEnabled,
tunOptions);
}
- public static Interface buildTunnelInterface(BigInteger dpn, String ifName, String desc, boolean enabled,
+ public static Interface buildTunnelInterface(Uint64 dpn, String ifName, String desc, boolean enabled,
Class<? extends TunnelTypeBase> tunType, IpAddress localIp,
IpAddress remoteIp, boolean internal,
Boolean monitorEnabled,
return builder.build();
}
- public static InternalTunnel buildInternalTunnel(BigInteger srcDpnId, BigInteger dstDpnId,
+ public static InternalTunnel buildInternalTunnel(Uint64 srcDpnId, Uint64 dstDpnId,
Class<? extends TunnelTypeBase> tunType,
String trunkInterfaceName) {
return new InternalTunnelBuilder().withKey(new InternalTunnelKey(dstDpnId, srcDpnId, tunType))
.replace("-", "");
}
- public static List<DPNTEPsInfo> getDpnTepListFromDpnId(DPNTEPsInfoCache dpnTEPsInfoCache, List<BigInteger> dpnIds) {
+ public static List<DPNTEPsInfo> getDpnTepListFromDpnId(DPNTEPsInfoCache dpnTEPsInfoCache, List<Uint64> dpnIds) {
Collection<DPNTEPsInfo> meshedDpnList = dpnTEPsInfoCache.getAllPresent();
List<DPNTEPsInfo> cfgDpnList = new ArrayList<>();
- for (BigInteger dpnId : dpnIds) {
+ for (Uint64 dpnId : dpnIds) {
for (DPNTEPsInfo teps : meshedDpnList) {
if (dpnId.equals(teps.getDPNID())) {
cfgDpnList.add(teps);
@SuppressWarnings("checkstyle:IllegalCatch")
public static void addTerminatingServiceTable(TypedReadWriteTransaction<Configuration> tx,
- BigInteger dpnId, IMdsalApiManager mdsalManager) {
+ Uint64 dpnId, IMdsalApiManager mdsalManager) {
LOG.trace("Installing PUNT to Controller flow in DPN {} ", dpnId);
List<ActionInfo> listActionInfo = new ArrayList<>();
listActionInfo.add(new ActionPuntToController());
try {
List<MatchInfo> mkMatches = new ArrayList<>();
- mkMatches.add(new MatchTunnelId(BigInteger.valueOf(ITMConstants.LLDP_SERVICE_ID)));
+ mkMatches.add(new MatchTunnelId(Uint64.valueOf(ITMConstants.LLDP_SERVICE_ID)));
List<InstructionInfo> mkInstructions = new ArrayList<>();
mkInstructions.add(new InstructionApplyActions(listActionInfo));
FlowEntity terminatingServiceTableFlowEntity = MDSALUtil
.buildFlowEntity(dpnId, NwConstants.INTERNAL_TUNNEL_TABLE,
getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE, ITMConstants.LLDP_SERVICE_ID),
- 5, String.format("%s:%d","ITM Flow Entry ", ITMConstants.LLDP_SERVICE_ID), 0, 0,
- ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(ITMConstants.LLDP_SERVICE_ID)),
- mkMatches, mkInstructions);
+ 5, String.format("%s:%d","ITM Flow Entry :", ITMConstants.LLDP_SERVICE_ID), 0, 0,
+ COOKIE_ITM_LLD, mkMatches, mkInstructions);
mdsalManager.addFlow(tx, terminatingServiceTableFlowEntity);
} catch (Exception e) {
LOG.error("Error while setting up Table 36 for {}", dpnId, e);
@SuppressWarnings("checkstyle:IllegalCatch")
public static void removeTerminatingServiceTable(TypedReadWriteTransaction<Configuration> tx,
- BigInteger dpnId, IMdsalApiManager mdsalManager) {
+ Uint64 dpnId, IMdsalApiManager mdsalManager) {
LOG.trace("Removing PUNT to Controller flow in DPN {} ", dpnId);
try {
return new ExternalTunnelKey(dst, src, tunType);
}
- public static List<TunnelEndPoints> getTEPsForDpn(BigInteger srcDpn, Collection<DPNTEPsInfo> dpnList) {
+ public static List<TunnelEndPoints> getTEPsForDpn(Uint64 srcDpn, Collection<DPNTEPsInfo> dpnList) {
for (DPNTEPsInfo dpn : dpnList) {
if (Objects.equals(dpn.getDPNID(), srcDpn)) {
return new ArrayList<>(dpn.nonnullTunnelEndPoints());
if (externalTunnels != null) {
for (ExternalTunnel tunnel : externalTunnels) {
String tunnelInterfaceName = tunnel.getTunnelInterfaceName();
- if (tunnelInterfaceName != null && (tunnelInterfaceName.equalsIgnoreCase(interfaceName))) {
+ if (tunnelInterfaceName != null && tunnelInterfaceName.equalsIgnoreCase(interfaceName)) {
LOG.trace("getExternalTunnelFromDS tunnelInterfaceName: {} ", tunnelInterfaceName);
return tunnel;
}
}
@NonNull
- public static List<TzMembership> getOriginalTzMembership(TunnelEndPoints srcTep, BigInteger dpnId,
+ public static List<TzMembership> getOriginalTzMembership(TunnelEndPoints srcTep, Uint64 dpnId,
Collection<DPNTEPsInfo> meshedDpnList) {
LOG.trace("Original Membership for source DPN {}, source TEP {}", dpnId, srcTep);
for (DPNTEPsInfo dstDpn : meshedDpnList) {
}
@NonNull
- public static Optional<InternalTunnel> getInternalTunnelFromDS(BigInteger srcDpn, BigInteger destDpn,
+ public static Optional<InternalTunnel> getInternalTunnelFromDS(Uint64 srcDpn, Uint64 destDpn,
Class<? extends TunnelTypeBase> type,
DataBroker dataBroker) {
InstanceIdentifier<InternalTunnel> pathLogicTunnel = InstanceIdentifier.create(TunnelList.class)
return tunType ;
}
- public static List<BigInteger> getDpIdFromTransportzone(DataBroker dataBroker, String tzone) {
- List<BigInteger> listOfDpId = new ArrayList<>();
+ public static List<Uint64> getDpIdFromTransportzone(DataBroker dataBroker, String tzone) {
+ List<Uint64> listOfDpId = new ArrayList<>();
InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class)
.child(TransportZone.class, new TransportZoneKey(tzone)).build();
Optional<TransportZone> transportZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
try {
Optional<TunnelMonitorInterval> maybeTunnelInterval =
tunnelMonitorIntervalCache.get(TUNNEL_MONITOR_INTERVAL_PATH);
- return maybeTunnelInterval.isPresent() ? maybeTunnelInterval.get().getInterval()
+ return maybeTunnelInterval.isPresent() ? maybeTunnelInterval.get().getInterval().toJava()
: ITMConstants.BFD_DEFAULT_MONITOR_INTERVAL;
} catch (ReadFailedException e) {
LOG.warn("Read of {} failed", TUNNEL_MONITOR_INTERVAL_PATH, e);
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private List<ListenableFuture<Void>> updateTunnelState(OvsdbTerminationPointAugmentation terminationPointNew) {
final String interfaceName = terminationPointNew.getName();
final Interface.OperStatus interfaceBfdStatus = getTunnelOpState(terminationPointNew);
import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
} else {
for (Map.Entry<String, NodeConnectorInfo> entry : meshedMap.entrySet()) {
- DpnTepInterfaceInfo infInfoForward = dpnTepStateCache.getDpnTepInterface(new BigInteger(srcDpn),
- new BigInteger(entry.getKey()));
+ DpnTepInterfaceInfo infInfoForward = dpnTepStateCache.getDpnTepInterface(Uint64.valueOf(srcDpn),
+ Uint64.valueOf(entry.getKey()));
if (infInfoForward == null) {
unprocessedNCCache.add(srcDpn + ":" + entry.getKey(),
new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo).build());
}
DpnTepInterfaceInfo infInfoReverse = dpnTepStateCache.getDpnTepInterface(
- new BigInteger(entry.getKey()), new BigInteger(srcDpn));
+ Uint64.valueOf(entry.getKey()), Uint64.valueOf(srcDpn));
if (infInfoReverse == null) {
unprocessedNCCache.add(entry.getKey() + ":" + srcDpn,
if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) {
tunnelEndPtInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(portName);
TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo);
- dpntePsInfoCache.getDPNTepFromDPNId(new BigInteger(tunnelEndPtInfo.getSrcEndPointInfo()))
+ dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getSrcEndPointInfo()))
.ifPresent(builder::setSrcDpnTepsInfo);
- dpntePsInfoCache.getDPNTepFromDPNId(new BigInteger(tunnelEndPtInfo.getDstEndPointInfo()))
+ dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getDstEndPointInfo()))
.ifPresent(builder::setDstDpnTepsInfo);
tunnelStateInfo = builder.setTunnelEndPointInfo(tunnelEndPtInfo)
.setDpnTepInterfaceInfo(dpnTepStateCache.getTunnelFromCache(portName)).build();
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private List<ListenableFuture<Void>> updateState(String interfaceName,
FlowCapableNodeConnector flowCapableNodeConnectorNew,
FlowCapableNodeConnector flowCapableNodeConnectorOld) {
return !dpnTepInterfaceInfo.isMonitoringEnabled() && modifyOpState(dpnTepInterfaceInfo, opStateModified);
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private List<ListenableFuture<Void>> removeInterfaceStateConfiguration(NodeConnectorId nodeConnectorId,
String interfaceName,
FlowCapableNodeConnector
List<ListenableFuture<Void>> futures = new ArrayList<>();
- BigInteger dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
+ Uint64 dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
// In a genuine port delete scenario, the reason will be there in the incoming event, for all remaining
// cases treat the event as DPN disconnect, if old and new ports are same. Else, this is a VM migration
// scenario, and should be treated as port removal.
LOG.debug("Received remove state for dpid {}", dpId.intValue());
for (Map.Entry<String, NodeConnectorInfo> entry : meshedMap.entrySet()) {
if (!dpId.toString().equals(entry.getKey())) {
- String fwdTunnel = dpnTepStateCache.getDpnTepInterface(dpId, new BigInteger(entry.getKey()))
+ String fwdTunnel = dpnTepStateCache.getDpnTepInterface(dpId, Uint64.valueOf(entry.getKey()))
.getTunnelName();
LOG.debug("Fwd Tunnel name for {} : {} is {}", dpId.intValue(), entry.getKey(), fwdTunnel);
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
tx -> updateInterfaceStateOnNodeRemove(tx, fwdTunnel, flowCapableNodeConnector)));
- String bwdTunnel = dpnTepStateCache.getDpnTepInterface(new BigInteger(entry.getKey()), dpId)
+ String bwdTunnel = dpnTepStateCache.getDpnTepInterface(Uint64.valueOf(entry.getKey()), dpId)
.getTunnelName();
LOG.debug("Bwd Tunnel name for {} : {} is {}", entry.getKey(), dpId.intValue(), bwdTunnel);
futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
return futures;
}
- private class TunnelInterfaceStateUpdateWorker implements Callable {
+ private class TunnelInterfaceStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
private final InstanceIdentifier<FlowCapableNodeConnector> key;
private final FlowCapableNodeConnector fcNodeConnectorOld;
private final FlowCapableNodeConnector fcNodeConnectorNew;
}
@Override
- public Object call() {
+ public List<ListenableFuture<Void>> call() {
// If another renderer(for eg : OVS) needs to be supported, check can be performed here
// to call the respective helpers.
return updateState(interfaceName, fcNodeConnectorNew, fcNodeConnectorOld);
}
}
- private class TunnelInterfaceStateRemoveWorker implements Callable {
+ private class TunnelInterfaceStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
private final NodeConnectorId nodeConnectorId;
private final FlowCapableNodeConnector flowCapableNodeConnector;
private final String interfaceName;
}
@Override
- public Object call() {
+ public List<ListenableFuture<Void>> call() {
// If another renderer(for eg : OVS) needs to be supported, check can be performed here
// to call the respective helpers.
return removeInterfaceStateConfiguration(nodeConnectorId, interfaceName, flowCapableNodeConnector);
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* This code is used to handle only a dpnId change scenario for a particular change,
* which is not expected to happen in usual cases.
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private List<ListenableFuture<Void>> updateOvsBridgeRefEntry(InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid,
- OvsdbBridgeAugmentation bridgeNew,
- OvsdbBridgeAugmentation bridgeOld) {
+ OvsdbBridgeAugmentation bridgeNew,
+ OvsdbBridgeAugmentation bridgeOld) {
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
- BigInteger dpnIdNew = directTunnelUtils.getDpnId(bridgeNew.getDatapathId());
- BigInteger dpnIdOld = directTunnelUtils.getDpnId(bridgeOld.getDatapathId());
+ Uint64 dpnIdNew = directTunnelUtils.getDpnId(bridgeNew.getDatapathId());
+ Uint64 dpnIdOld = directTunnelUtils.getDpnId(bridgeOld.getDatapathId());
LOG.debug("updating bridge references for bridge: {}, dpnNew: {}, dpnOld: {}", bridgeNew,
dpnIdNew, dpnIdOld);
}));
}
- public List<ListenableFuture<Void>> removePortFromBridge(InstanceIdentifier<OvsdbBridgeAugmentation>
- bridgeIid,
- OvsdbBridgeAugmentation bridgeOld) {
- BigInteger dpnId = directTunnelUtils.getDpnId(bridgeOld.getDatapathId());
+ public List<ListenableFuture<Void>> removePortFromBridge(InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid,
+ OvsdbBridgeAugmentation bridgeOld) {
+ Uint64 dpnId = directTunnelUtils.getDpnId(bridgeOld.getDatapathId());
if (dpnId == null) {
LOG.warn("Got Null DPID for Bridge: {}", bridgeOld);
return Collections.emptyList();
}));
}
- private void createOvsBridgeRefEntry(BigInteger dpnId, InstanceIdentifier<?> bridgeIid,
- WriteTransaction tx) {
+ private void createOvsBridgeRefEntry(Uint64 dpnId, InstanceIdentifier<?> bridgeIid, WriteTransaction tx) {
LOG.debug("Creating bridge ref entry for dpn: {} bridge: {}",
dpnId, bridgeIid);
OvsBridgeRefEntryKey bridgeRefEntryKey = new OvsBridgeRefEntryKey(dpnId);
tx.put(LogicalDatastoreType.OPERATIONAL, bridgeEntryId, tunnelDpnBridgeEntryBuilder.build(), true);
}
- private void deleteOvsBridgeRefEntry(BigInteger dpnId,
- WriteTransaction tx) {
+ private void deleteOvsBridgeRefEntry(Uint64 dpnId, WriteTransaction tx) {
LOG.debug("Deleting bridge ref entry for dpn: {}",
dpnId);
OvsBridgeRefEntryKey bridgeRefEntryKey = new OvsBridgeRefEntryKey(dpnId);
tx.delete(LogicalDatastoreType.OPERATIONAL, bridgeEntryId);
}
- private void addBridgeRefToBridgeTunnelEntry(BigInteger dpId, OvsdbBridgeRef ovsdbBridgeRef, WriteTransaction tx) {
+ private void addBridgeRefToBridgeTunnelEntry(Uint64 dpId, OvsdbBridgeRef ovsdbBridgeRef, WriteTransaction tx) {
OvsBridgeEntryKey bridgeEntryKey = new OvsBridgeEntryKey(dpId);
InstanceIdentifier<OvsBridgeEntry> bridgeEntryInstanceIdentifier =
DirectTunnelUtils.getOvsBridgeEntryIdentifier(bridgeEntryKey);
return Collections.emptyList();
}
- BigInteger dpnId = directTunnelUtils.getDpnId(bridgeNew.getDatapathId());
+ Uint64 dpnId = directTunnelUtils.getDpnId(bridgeNew.getDatapathId());
LOG.debug("adding bridge references for bridge: {}, dpn: {}", bridgeNew, dpnId);
EVENT_LOGGER.debug("TunnelTopologyState, ADD bridge {} for {}", bridgeNew.getBridgeName(), dpnId);
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.util.concurrent.ListenableFuture;
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
-import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
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.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return tunnelLocks.acquire(tunnelName);
}
- public BigInteger getDpnId(DatapathId datapathId) {
+ public Uint64 getDpnId(DatapathId datapathId) {
if (datapathId != null) {
String dpIdStr = datapathId.getValue().replace(":", "");
- return new BigInteger(dpIdStr, 16);
+ return Uint64.valueOf(dpIdStr, 16);
}
return null;
}
- public static BigInteger getDpnFromNodeConnectorId(NodeConnectorId portId) {
+ public static Uint64 getDpnFromNodeConnectorId(NodeConnectorId portId) {
/*
* NodeConnectorId is of form 'openflow:dpnid:portnum'
*/
- return new BigInteger(portId.getValue().split(ITMConstants.OF_URI_SEPARATOR)[1]);
+ return Uint64.valueOf(portId.getValue().split(ITMConstants.OF_URI_SEPARATOR)[1]);
}
public static long getPortNumberFromNodeConnectorId(NodeConnectorId portId) {
.child(OvsBridgeRefEntry.class, bridgeRefEntryKey).build();
}
- public static InstanceIdentifier<DpnsTeps> createDpnTepsInstanceIdentifier(BigInteger sourceDpnId) {
+ public static InstanceIdentifier<DpnsTeps> createDpnTepsInstanceIdentifier(Uint64 sourceDpnId) {
return InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class,
new DpnsTepsKey(sourceDpnId)).build();
}
}
}
- public static void createBridgeTunnelEntryInConfigDS(BigInteger dpId, String childInterface) {
+ public static void createBridgeTunnelEntryInConfigDS(Uint64 dpId, String childInterface) {
OvsBridgeEntryKey bridgeEntryKey = new OvsBridgeEntryKey(dpId);
OvsBridgeTunnelEntryKey bridgeTunnelEntryKey = new OvsBridgeTunnelEntryKey(childInterface);
InstanceIdentifier<OvsBridgeTunnelEntry> bridgeTunnelEntryIid =
ITMBatchingUtils.write(bridgeTunnelEntryIid, entryBuilder.build(), ITMBatchingUtils.EntityType.DEFAULT_CONFIG);
}
- public void addTunnelIngressFlow(TypedWriteTransaction<Configuration> tx, BigInteger dpnId, long portNo,
+ public void addTunnelIngressFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpnId, long portNo,
String interfaceName, int ifIndex, Ipv4Address ipAddress) {
LOG.debug("Adding tunnel ingress flow for {}", interfaceName);
List<MatchInfoBase> matches = new ArrayList<>();
if (itmConfig.isUseOfTunnels()) {
matches.add(new NxMatchTunnelSourceIp(ipAddress));
}
- mkInstructions.add(new InstructionWriteMetadata(MetaDataUtil.getLportTagMetaData(ifIndex)
- .or(BigInteger.ONE), MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG));
+ mkInstructions.add(new InstructionWriteMetadata(
+ Uint64.fromLongBits(MetaDataUtil.getLportTagMetaData(ifIndex).longValue() | 1L),
+ MetaDataUtil.METADATA_MASK_LPORT_TAG_SH_FLAG));
short tableId = NwConstants.INTERNAL_TUNNEL_TABLE;
mkInstructions.add(new InstructionGotoTable(tableId));
mdsalApiManager.addFlow(tx, flowEntity);
}
- public void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpnId,
+ public void removeTunnelIngressFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpnId,
String interfaceName) throws ExecutionException, InterruptedException {
LOG.debug("Removing tunnel ingress flow for {}", interfaceName);
String flowRef =
mdsalApiManager.removeFlow(tx, dpnId, flowRef, NwConstants.VLAN_INTERFACE_INGRESS_TABLE);
}
- public void addTunnelEgressFlow(TypedWriteTransaction<Configuration> tx, BigInteger dpnId, String portNo,
+ public void addTunnelEgressFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpnId, String portNo,
int dstId, String interfaceName, IpAddress dstIp) {
LOG.debug("add tunnel egress flow for {}", interfaceName);
List<MatchInfoBase> matches = new ArrayList<>();
mdsalApiManager.addFlow(tx, dpnId, egressFlow);
}
- public void removeTunnelEgressFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpnId,
+ public void removeTunnelEgressFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpnId,
String interfaceName) throws ExecutionException, InterruptedException {
LOG.debug("remove tunnel egress flow for {}", interfaceName);
String flowRef =
mdsalApiManager.removeFlow(tx, dpnId, flowRef, NwConstants.EGRESS_TUNNEL_TABLE);
}
- private String getTunnelInterfaceFlowRef(BigInteger dpnId, short tableId, String ifName) {
+ private String getTunnelInterfaceFlowRef(Uint64 dpnId, short tableId, String ifName) {
return String.valueOf(dpnId) + tableId + ifName;
}
int vlanId = 0;
IfL2vlan ifL2vlan = iface.augmentation(IfL2vlan.class);
if (ifL2vlan != null && ifL2vlan.getVlanId() != null) {
- vlanId = ifL2vlan.getVlanId().getValue();
+ vlanId = ifL2vlan.getVlanId().getValue().toJava();
}
Builder<String, String> options = new ImmutableMap.Builder<>();
ITMBatchingUtils.delete(stateTnlId, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
}
- public void updateBfdConfiguration(BigInteger srcDpnId, RemoteDpns remoteDpn,
+ public void updateBfdConfiguration(Uint64 srcDpnId, RemoteDpns remoteDpn,
com.google.common.base.@NonNull Optional<OvsBridgeRefEntry> ovsBridgeRefEntry) {
if (ovsBridgeRefEntry.isPresent()) {
LOG.debug("creating bridge interface on dpn {}", srcDpnId);
return entityOwnershipUtils.isEntityOwner(ITMConstants.ITM_CONFIG_ENTITY, ITMConstants.ITM_CONFIG_ENTITY);
}
- public static String generateOfPortName(BigInteger dpId, String tunnelType) {
+ public static String generateOfPortName(Uint64 dpId, String tunnelType) {
String trunkInterfaceName = String.format("%s:%s", dpId.toString(), tunnelType);
String uuidStr = UUID.nameUUIDFromBytes(trunkInterfaceName.getBytes(StandardCharsets.UTF_8)).toString()
.substring(0, 12).replace("-", "");
package org.opendaylight.genius.itm.itmdirecttunnels.workers;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (stateTnl != null) {
return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> {
- BigInteger dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
- directTunnelUtils.addTunnelIngressFlow(tx, dpId, portNo, interfaceName, stateTnl.getIfIndex(),
+ Uint64 dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
+ directTunnelUtils.addTunnelIngressFlow(tx, dpId, portNo, interfaceName,
+ stateTnl.getIfIndex().toJava(),
tunnelStateInfo.getDstDpnTepsInfo().getTunnelEndPoints().get(0).getIpAddress()
.getIpv4Address());
directTunnelUtils.addTunnelEgressFlow(tx, dpId, String.valueOf(portNo),
package org.opendaylight.genius.itm.listeners;
-import java.math.BigInteger;
import java.time.Duration;
import java.util.List;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
if (isTzChanged) {
IpAddress tepIpAddress = IpAddressBuilder.getDefaultInstance(newLocalIp);
- BigInteger dpnId = MDSALUtil.getDpnId(strNewDpnId);
+ Uint64 dpnId = MDSALUtil.getDpnId(strNewDpnId);
String tos = itmConfig.getDefaultTunnelTos();
Class<? extends TunnelTypeBase> tunnelType = TunnelTypeVxlan.class;
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(oldTzName);
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
+ : ITMConstants.DUMMY_VLANID;
TunnelEndPoints tunnelEndPoints = ItmUtils.createDummyTunnelEndPoints(dpnId, tepIpAddress, newOfTunnel,
tos, zones, tunnelType, portName, vlanId);
import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
private List<DPNTEPsInfo> createDPNTepInfoFromNotHosted(TransportZone tzNew, List<DPNTEPsInfo> opDpnList) {
- Map<BigInteger, List<TunnelEndPoints>> mapNotHostedDPNToTunnelEndpt = new ConcurrentHashMap<>();
+ Map<Uint64, List<TunnelEndPoints>> mapNotHostedDPNToTunnelEndpt = new ConcurrentHashMap<>();
List<DPNTEPsInfo> notHostedDpnTepInfo = new ArrayList<>();
String newZoneName = tzNew.getZoneName();
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(newZoneName);
List<Vteps> vtepsList = new ArrayList<>();
if (unVtepsLst != null && !unVtepsLst.isEmpty()) {
for (UnknownVteps vteps : unVtepsLst) {
- BigInteger dpnID = vteps.getDpnId();
+ Uint64 dpnID = vteps.getDpnId();
IpAddress ipAddress = vteps.getIpAddress();
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava()
+ : ITMConstants.DUMMY_VLANID;
boolean useOfTunnel = ItmUtils.falseIfNull(vteps.isOfTunnel());
String tos = vteps.getOptionTunnelTos();
if (tos == null) {
jobCoordinator.enqueueJob(newZoneName, new ItmTepsNotHostedMoveWorker(vtepsList, newZoneName, txRunner));
if (mapNotHostedDPNToTunnelEndpt.size() > 0) {
- for (Entry<BigInteger, List<TunnelEndPoints>> entry: mapNotHostedDPNToTunnelEndpt.entrySet()) {
+ for (Entry<Uint64, List<TunnelEndPoints>> entry: mapNotHostedDPNToTunnelEndpt.entrySet()) {
DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
notHostedDpnTepInfo.add(newDpnTepsInfo);
}
}
- private Vteps createVtepFromUnKnownVteps(BigInteger dpnID, IpAddress ipAddress) {
+ private Vteps createVtepFromUnKnownVteps(Uint64 dpnID, IpAddress ipAddress) {
VtepsKey vtepkey = new VtepsKey(dpnID);
Vteps vtepObj = new VtepsBuilder().setDpnId(dpnID).setIpAddress(ipAddress).withKey(vtepkey)
.build();
private List<DPNTEPsInfo> createDPNTepInfo(TransportZone transportZone) {
- Map<BigInteger, List<TunnelEndPoints>> mapDPNToTunnelEndpt = new ConcurrentHashMap<>();
+ Map<Uint64, List<TunnelEndPoints>> mapDPNToTunnelEndpt = new ConcurrentHashMap<>();
List<DPNTEPsInfo> dpnTepInfo = new ArrayList<>();
List<TzMembership> zones = ItmUtils.createTransportZoneMembership(transportZone.getZoneName());
Class<? extends TunnelTypeBase> tunnelType = transportZone.getTunnelType();
LOG.trace("Transport Zone_name: {}", transportZone.getZoneName());
List<Vteps> vtepsList = transportZone.getVteps();
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
if (vtepsList != null && !vtepsList.isEmpty()) {
for (Vteps vteps : vtepsList) {
- BigInteger dpnID = vteps.getDpnId();
+ Uint64 dpnID = vteps.getDpnId();
IpAddress ipAddress = vteps.getIpAddress();
boolean useOfTunnel = itmConfig.isUseOfTunnels();
String tos = vteps.getOptionTunnelTos();
if (!mapDPNToTunnelEndpt.isEmpty()) {
LOG.trace("List of dpns in the Map: {} ", mapDPNToTunnelEndpt.keySet());
- for (Entry<BigInteger, List<TunnelEndPoints>> entry : mapDPNToTunnelEndpt.entrySet()) {
+ for (Entry<Uint64, List<TunnelEndPoints>> entry : mapDPNToTunnelEndpt.entrySet()) {
DPNTEPsInfo newDpnTepsInfo = ItmUtils.createDPNTepInfo(entry.getKey(), entry.getValue());
dpnTepInfo.add(newDpnTepsInfo);
}
ovsBridgeRefEntryCache));
} else {
ItmMonitorIntervalWorker toggleWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
- dataObjectModification.getInterval(), broker);
+ dataObjectModification.getInterval().toJava(), broker);
jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
}
}
jobCoordinator.enqueueJob(tzone.getZoneName(), monitorWorker);
} else {
ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
- dataObjectModificationAfter.getInterval(), broker);
+ dataObjectModificationAfter.getInterval().toJava(), broker);
jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
}
}
jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
} else {
ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
- dataObjectModification.getInterval(), broker);
+ dataObjectModification.getInterval().toJava(), broker);
//conversion to milliseconds done while writing to i/f-mgr config DS
jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
}
package org.opendaylight.genius.itm.monitoring;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final JobCoordinator jobCoordinator;
private final ManagedNewTransactionRunner txRunner;
private JMXAlarmAgent alarmAgent;
- private UnprocessedTunnelsStateCache unprocessedTunnelsStateCache;
+ private final UnprocessedTunnelsStateCache unprocessedTunnelsStateCache;
@Inject
public ItmTunnelEventListener(DataBroker dataBroker, JobCoordinator jobCoordinator,
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void raiseInternalDataPathAlarm(String srcDpnId, String dstDpnId, String tunnelType, String alarmText) {
StringBuilder source = new StringBuilder();
source.append("srcDpn=openflow:").append(srcDpnId).append("-dstDpn=openflow:").append(dstDpnId)
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void clearInternalDataPathAlarm(String srcDpnId, String dstDpnId, String tunnelType, String alarmText) {
StringBuilder source = new StringBuilder();
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void raiseExternalDataPathAlarm(String srcDevice, String dstDevice, String tunnelType, String alarmText) {
StringBuilder source = new StringBuilder();
}
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void clearExternalDataPathAlarm(String srcDevice, String dstDevice, String tunnelType, String alarmText) {
StringBuilder source = new StringBuilder();
source.append("srcDevice=").append(srcDevice).append("-dstDevice=").append(dstDevice).append("-tunnelType")
}
}
- private boolean isTunnelInterfaceUp(StateTunnelList intf) {
- return (intf.getOperState() == TunnelOperStatus.Up);
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static boolean isTunnelInterfaceUp(StateTunnelList intf) {
+ return intf.getOperState() == TunnelOperStatus.Up;
}
- private String getInternalAlarmText(String srcDpId, String dstDpId, String tunnelType) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static String getInternalAlarmText(String srcDpId, String dstDpId, String tunnelType) {
StringBuilder alarmText = new StringBuilder();
alarmText.append("Data Path Connectivity is lost between ").append("openflow:").append(srcDpId)
.append(" and openflow:").append(dstDpId).append(" for tunnelType:").append(tunnelType);
return alarmText.toString();
}
- private String getExternalAlarmText(String srcNode, String dstNode, String tunnelType) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static String getExternalAlarmText(String srcNode, String dstNode, String tunnelType) {
StringBuilder alarmText = new StringBuilder();
alarmText.append("Data Path Connectivity is lost between ").append(srcNode).append(" and ").append(dstNode)
.append(" for tunnelType:").append(tunnelType);
String ifName = add.getTunnelInterfaceName();
InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName, broker);
if (internalTunnel != null) {
- BigInteger srcDpId = internalTunnel.getSourceDPN();
- BigInteger dstDpId = internalTunnel.getDestinationDPN();
+ Uint64 srcDpId = internalTunnel.getSourceDPN();
+ Uint64 dstDpId = internalTunnel.getDestinationDPN();
String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
if (!isTunnelInterfaceUp(add)) {
LOG.trace("ITM Tunnel State during tep add is DOWN b/w srcDpn: {} and dstDpn: {} for tunnelType: "
String ifName = del.getTunnelInterfaceName();
InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName, broker);
if (internalTunnel != null) {
- BigInteger srcDpId = internalTunnel.getSourceDPN();
- BigInteger dstDpId = internalTunnel.getDestinationDPN();
+ Uint64 srcDpId = internalTunnel.getSourceDPN();
+ Uint64 dstDpId = internalTunnel.getDestinationDPN();
String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
LOG.trace("ITM Tunnel removed b/w srcDpn: {} and dstDpn: {} for tunnelType: {}", srcDpId, dstDpId,
tunnelType);
String ifName = update.getTunnelInterfaceName();
InternalTunnel internalTunnel = ItmUtils.getInternalTunnel(ifName, broker);
if (internalTunnel != null) {
- BigInteger srcDpId = internalTunnel.getSourceDPN();
- BigInteger dstDpId = internalTunnel.getDestinationDPN();
+ Uint64 srcDpId = internalTunnel.getSourceDPN();
+ Uint64 dstDpId = internalTunnel.getDestinationDPN();
String tunnelType = ItmUtils.convertTunnelTypetoString(internalTunnel.getTransportType());
if (LOG.isTraceEnabled()) {
LOG.trace("ITM Tunnel state event changed from :{} to :{} for Tunnel Interface - {}",
}
private static class ItmTunnelStatusOutOfOrderEventWorker implements Callable<List<ListenableFuture<Void>>> {
- private InstanceIdentifier<StateTunnelList> identifier;
- private StateTunnelList add;
- private TunnelOperStatus operStatus;
- private ManagedNewTransactionRunner txRunner;
+ private final InstanceIdentifier<StateTunnelList> identifier;
+ private final StateTunnelList add;
+ private final TunnelOperStatus operStatus;
+ private final ManagedNewTransactionRunner txRunner;
ItmTunnelStatusOutOfOrderEventWorker(InstanceIdentifier<StateTunnelList> identifier, StateTunnelList add,
TunnelOperStatus operStatus,
return null;
}
- String portName = (itmConfig.getPortname() == null) ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
- int vlanId = (itmConfig.getVlanId() != null) ? itmConfig.getVlanId() : ITMConstants.DUMMY_VLANID;
+ String portName = itmConfig.getPortname() == null ? ITMConstants.DUMMY_PORT : itmConfig.getPortname();
+ int vlanId = itmConfig.getVlanId() != null ? itmConfig.getVlanId().toJava() : ITMConstants.DUMMY_VLANID;
for (Vteps vtep : transportZone.getVteps()) {
if (ipAddress.equals(vtep.getIpAddress().stringValue())) {
*/
package org.opendaylight.genius.itm.recovery.impl;
-import java.math.BigInteger;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
import org.opendaylight.yang.gen.v1.urn.opendaylight.serviceutils.srm.types.rev180626.GeniusItmTz;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
List<String> tunnelList = new ArrayList<>();
if (interfaceManager.isItmDirectTunnelsEnabled()) {
Collection<DpnsTeps> dpnsTeps = dpnTepStateCache.getAllPresent();
- List<BigInteger> listOfDpnIds = ItmUtils.getDpIdFromTransportzone(dataBroker, entityId);
+ List<Uint64> listOfDpnIds = ItmUtils.getDpIdFromTransportzone(dataBroker, entityId);
for (DpnsTeps dpnTep : dpnsTeps) {
List<RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
for (RemoteDpns remoteDpn : rmtdpns) {
package org.opendaylight.genius.itm.rpc;
import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-import static org.opendaylight.serviceutils.tools.rpc.FutureRpcResults.LogLevel.ERROR;
import static org.opendaylight.serviceutils.tools.rpc.FutureRpcResults.fromListenableFuture;
import static org.opendaylight.yangtools.yang.common.RpcResultBuilder.failed;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults;
+import org.opendaylight.serviceutils.tools.rpc.FutureRpcResults.LogLevel;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
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.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public ListenableFuture<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
GetTunnelInterfaceNameInput input) {
RpcResultBuilder<GetTunnelInterfaceNameOutput> resultBld = null;
- BigInteger sourceDpn = input.getSourceDpid();
- BigInteger destinationDpn = input.getDestinationDpid();
+ Uint64 sourceDpn = input.getSourceDpid();
+ Uint64 destinationDpn = input.getDestinationDpid();
Optional<InternalTunnel> optTunnel = Optional.absent();
if (interfaceManager.isItmDirectTunnelsEnabled()) {
return settableFuture;
} else {
return fromListenableFuture(LOG, input, () -> getEgressActionsForInternalTunnels(input.getIntfName(),
- input.getTunnelKey(), input.getActionKey())).onFailureLogLevel(ERROR).build();
+ input.getTunnelKey().toJava(), input.getActionKey())).onFailureLogLevel(LogLevel.ERROR).build();
}
}
@Override
public ListenableFuture<RpcResult<SetBfdParamOnTunnelOutput>> setBfdParamOnTunnel(
SetBfdParamOnTunnelInput input) {
- final BigInteger srcDpnId = new BigInteger(input.getSourceNode());
- final BigInteger destDpnId = new BigInteger(input.getDestinationNode());
+ final Uint64 srcDpnId = Uint64.valueOf(input.getSourceNode());
+ final Uint64 destDpnId = Uint64.valueOf(input.getDestinationNode());
LOG.debug("setBfdParamOnTunnel srcDpnId: {}, destDpnId: {}", srcDpnId, destDpnId);
final SettableFuture<RpcResult<SetBfdParamOnTunnelOutput>> result = SettableFuture.create();
FluentFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- enableBFD(tx, srcDpnId, destDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval());
- enableBFD(tx, destDpnId, srcDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval());
+ enableBFD(tx, srcDpnId, destDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval().toJava());
+ enableBFD(tx, destDpnId, srcDpnId, input.isMonitoringEnabled(), input.getMonitoringInterval().toJava());
});
future.addCallback(new FutureCallback<Void>() {
return result;
}
- private void enableBFD(TypedWriteTransaction<Datastore.Configuration> tx, BigInteger srcDpnId, BigInteger destDpnId,
+ private void enableBFD(TypedWriteTransaction<Datastore.Configuration> tx, Uint64 srcDpnId, Uint64 destDpnId,
final Boolean enabled, final Integer interval) throws ReadFailedException {
DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepStateCache.getDpnTepInterface(srcDpnId, destDpnId);
RemoteDpnsBuilder remoteDpnsBuilder = new RemoteDpnsBuilder();
LOG.info("create terminatingServiceAction on DpnId = {} for service id {} and instructions {}",
input.getDpnId() , input.getServiceId(), input.getInstruction());
final SettableFuture<RpcResult<CreateTerminatingServiceActionsOutput>> result = SettableFuture.create();
- int serviceId = input.getServiceId() ;
+ Uint16 serviceId = input.getServiceId();
final List<MatchInfo> mkMatches = getTunnelMatchesForServiceId(serviceId);
Flow terminatingServiceTableFlow = MDSALUtil.buildFlowNew(NwConstants.INTERNAL_TUNNEL_TABLE,
- getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE,serviceId), 5,
- String.format("%s:%d","ITM Flow Entry ",serviceId), 0, 0,
- ITMConstants.COOKIE_ITM.add(BigInteger.valueOf(serviceId)),mkMatches, input.getInstruction());
+ getFlowRef(NwConstants.INTERNAL_TUNNEL_TABLE, serviceId), 5,
+ String.format("%s:%d", "ITM Flow Entry ", serviceId), 0, 0,
+ Uint64.fromLongBits(ITMConstants.COOKIE_ITM.longValue() + serviceId.toJava()), mkMatches,
+ input.getInstruction());
ListenableFuture<Void> installFlowResult = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
tx -> mdsalManager.addFlow(tx, input.getDpnId(), terminatingServiceTableFlow));
return result ;
}
-
- public List<MatchInfo> getTunnelMatchesForServiceId(int serviceId) {
+ public List<MatchInfo> getTunnelMatchesForServiceId(Uint16 serviceId) {
final List<MatchInfo> mkMatches = new ArrayList<>();
// Matching metadata
- mkMatches.add(new MatchTunnelId(BigInteger.valueOf(serviceId)));
+ mkMatches.add(new MatchTunnelId(Uint64.valueOf(serviceId)));
return mkMatches;
}
- private String getFlowRef(long termSvcTable, int svcId) {
+ private String getFlowRef(long termSvcTable, Uint16 svcId) {
return String.valueOf(termSvcTable) + svcId;
}
public ListenableFuture<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
GetInternalOrExternalInterfaceNameInput input) {
RpcResultBuilder<GetInternalOrExternalInterfaceNameOutput> resultBld = failed();
- BigInteger srcDpn = input.getSourceDpid() ;
+ Uint64 srcDpn = input.getSourceDpid();
IpAddress dstIp = input.getDestinationIp() ;
InstanceIdentifier<ExternalTunnel> path1 = InstanceIdentifier.create(ExternalTunnelList.class)
.child(ExternalTunnel.class,
@Override
public ListenableFuture<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
- BigInteger srcDpn = input.getSourceDpid() ;
+ Uint64 srcDpn = input.getSourceDpid();
RpcResultBuilder<GetDpnEndpointIpsOutput> resultBld = failed();
InstanceIdentifier<DPNTEPsInfo> tunnelInfoId =
InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class,
}
private GetDpnInfoOutput getDpnInfoInternal(GetDpnInfoInput input) throws ReadFailedException {
- Map<String, BigInteger> computeNamesVsDpnIds
+ Map<String, Uint64> computeNamesVsDpnIds
= getDpnIdByComputeNodeNameFromOpInventoryNodes(input.getComputeNames());
- Map<BigInteger, ComputesBuilder> dpnIdVsVtepsComputes
+ Map<Uint64, ComputesBuilder> dpnIdVsVtepsComputes
= getTunnelEndPointByDpnIdFromTranPortZone(computeNamesVsDpnIds.values());
List<Computes> computes = computeNamesVsDpnIds.entrySet().stream()
.map(entry -> dpnIdVsVtepsComputes.get(entry.getValue()).setComputeName(entry.getKey()).build())
return new GetDpnInfoOutputBuilder().setComputes(computes).build();
}
- private Map<BigInteger, ComputesBuilder> getTunnelEndPointByDpnIdFromTranPortZone(Collection<BigInteger> dpnIds)
+ private Map<Uint64, ComputesBuilder> getTunnelEndPointByDpnIdFromTranPortZone(Collection<Uint64> dpnIds)
throws ReadFailedException {
TransportZones transportZones = singleTransactionDataBroker.syncRead(
LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(TransportZones.class).build());
if (transportZones.getTransportZone() == null || transportZones.getTransportZone().isEmpty()) {
throw new IllegalStateException("Failed to find transport zones in config datastore");
}
- Map<BigInteger, ComputesBuilder> result = new HashMap<>();
+ Map<Uint64, ComputesBuilder> result = new HashMap<>();
for (TransportZone transportZone : transportZones.getTransportZone()) {
for (Vteps vtep : transportZone.getVteps()) {
if (dpnIds.contains(vtep.getDpnId())) {
}
}
}
- for (BigInteger dpnId : dpnIds) {
+ for (Uint64 dpnId : dpnIds) {
if (!result.containsKey(dpnId)) {
throw new IllegalStateException("Failed to find dpn id " + dpnId + " in transport zone");
}
return result;
}
- private Map<String, BigInteger> getDpnIdByComputeNodeNameFromOpInventoryNodes(List<String> nodeNames)
+ private Map<String, Uint64> getDpnIdByComputeNodeNameFromOpInventoryNodes(List<String> nodeNames)
throws ReadFailedException {
Nodes operInventoryNodes = singleTransactionDataBroker.syncRead(
LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(Nodes.class).build());
if (operInventoryNodes.getNode() == null || operInventoryNodes.getNode().isEmpty()) {
throw new IllegalStateException("Failed to find operational inventory nodes datastore");
}
- Map<String, BigInteger> result = new HashMap<>();
+ Map<String, Uint64> result = new HashMap<>();
for (Node node : operInventoryNodes.getNode()) {
String name = node.augmentation(FlowCapableNode.class).getDescription();
if (nodeNames.contains(name)) {
String[] nodeId = node.getId().getValue().split(":");
- result.put(name, new BigInteger(nodeId[1]));
+ result.put(name, Uint64.valueOf(nodeId[1]));
}
}
for (String nodeName : nodeNames) {
return result;
}
- private String getNodeId(BigInteger dpnId) throws ReadFailedException {
+ private String getNodeId(Uint64 dpnId) throws ReadFailedException {
InstanceIdentifier<BridgeRefEntry> path = InstanceIdentifier
.builder(BridgeRefInfo.class)
.child(BridgeRefEntry.class, new BridgeRefEntryKey(dpnId)).build();
}
Optional<DPNTEPsInfo> dpntePsInfoOptional = dpnTEPsInfoCache.get(InstanceIdentifier.builder(DpnEndpoints.class)
- .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(new BigInteger(dpnTepStateCache
- .getTunnelEndPointInfoFromCache(interfaceInfo.getTunnelName()).getDstEndPointInfo()))).build());
+ .child(DPNTEPsInfo.class, new DPNTEPsInfoKey(
+ // FIXME: the cache should be caching this value, not just as a String
+ Uint64.valueOf(dpnTepStateCache.getTunnelEndPointInfoFromCache(interfaceInfo.getTunnelName())
+ .getDstEndPointInfo())))
+ .build());
Integer dstId;
if (dpntePsInfoOptional.isPresent()) {
dstId = dpntePsInfoOptional.get().getDstId();
long regValue = MetaDataUtil.getRemoteDpnMetadatForEgressTunnelTable(dstId);
int actionKeyStart = actionKey == null ? 0 : actionKey;
result.add(new ActionSetFieldTunnelId(actionKeyStart++,
- BigInteger.valueOf(tunnelKey != null ? tunnelKey : 0L)));
+ Uint64.valueOf(tunnelKey != null ? tunnelKey : 0L)));
result.add(new ActionRegLoad(actionKeyStart++, NxmNxReg6.class, MetaDataUtil.REG6_START_INDEX,
MetaDataUtil.REG6_END_INDEX, regValue));
result.add(new ActionNxResubmit(actionKeyStart, NwConstants.EGRESS_TUNNEL_TABLE));
tx.read(InstanceIdentifier.builder(DcGatewayIpList.class).build());
future.addCallback(new FutureCallback<Optional<DcGatewayIpList>>() {
@Override
- public void onSuccess(@NonNull Optional<DcGatewayIpList> optional) {
+ public void onSuccess(Optional<DcGatewayIpList> optional) {
try {
+ // FIXME: why not just use the provided optional?
Optional<DcGatewayIpList> opt = future.get();
if (opt.isPresent()) {
DcGatewayIpList list = opt.get();
import com.google.common.util.concurrent.Futures;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final String sourceDevice = "hwvtep://192.168.101.30:6640/physicalswitch/s3";
private final String destinationDevice = "hwvtep:1";
private final String transportZone1 = "TZA" ;
- private final BigInteger dpId1 = BigInteger.valueOf(1);
- private final BigInteger dpId2 = BigInteger.valueOf(2);
+ private final Uint64 dpId1 = Uint64.ONE;
+ private final Uint64 dpId2 = Uint64.valueOf(2);
private final IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
private final IpAddress ipAddress2 = IpAddressBuilder.getDefaultInstance(tepIp2);
private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
.CONFIGURATION,transportZoneIdentifier);
- tepCommandHelper.configureTunnelType(transportZone1,"VXLAN");
+ tepCommandHelper.configureTunnelType(transportZone1, "VXLAN");
- verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
- verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZones,true);
+ verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
+
+ final List<TransportZone> newList = new ArrayList<>(transportZoneList);
+ newList.add(new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
+ .setTunnelType(TunnelTypeVxlan.class).build());
+
+ verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, transportZonesIdentifier,
+ new TransportZonesBuilder().setTransportZone(newList).build(),true);
}
@Test
public void testIsInCache() {
try {
- tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
- tepCommandHelper.isInCache(dpId1,tepIp1,transportZone1);
+ tepCommandHelper.createLocalCache(dpId1, tepIp1, transportZone1);
+ tepCommandHelper.isInCache(dpId1, tepIp1 ,transportZone1);
} catch (TepException e) {
LOG.error(e.getMessage());
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.impl;
import static org.mockito.Mockito.doReturn;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
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.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class ItmExternalTunnelAddTest {
- BigInteger dpId1 = BigInteger.valueOf(1);
+ Uint64 dpId1 = Uint64.ONE;
int vlanId = 100 ;
int interval = 1000;
String portName1 = "phy0";
Interface iface = null;
List<DPNTEPsInfo> cfgdDpnListVxlan = new ArrayList<>() ;
List<TunnelEndPoints> tunnelEndPointsListVxlan = new ArrayList<>();
- List<BigInteger> bigIntegerList = new ArrayList<>();
+ List<Uint64> bigIntegerList = new ArrayList<>();
List<HwVtep> cfgdHwVtepsList = new ArrayList<>();
List<DeviceVteps> deviceVtepsList = new ArrayList<>();
List<Vteps> vtepsList = new ArrayList<>();
lenient().doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
doReturn("phy0").when(itmConfig).getPortname();
- doReturn(100).when(itmConfig).getVlanId();
+ doReturn(Uint16.valueOf(100)).when(itmConfig).getVlanId();
}
@Test
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
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.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class ItmExternalTunnelDeleteTest {
IpAddress gtwyIp1 = null;
IpAddress gtwyIp2 = null;
IpPrefix ipPrefixTest = null;
- BigInteger dpId2 = BigInteger.valueOf(1);
+ Uint64 dpId2 = Uint64.ONE;
DPNTEPsInfo dpntePsInfoVxlan = null;
TunnelEndPoints tunnelEndPointsVxlan = null;
HwVtep hwVtep1 = null;
lenient().doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
lenient().doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
doReturn("phy0").when(itmConfig).getPortname();
- doReturn(100).when(itmConfig).getVlanId();
+ doReturn(Uint16.valueOf(100)).when(itmConfig).getVlanId();
}
@Test
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.impl;
import static org.mockito.Mockito.doReturn;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@PrepareForTest(ITMBatchingUtils.class)
public class ItmInternalTunnelAddTest {
- BigInteger dpId1 = BigInteger.valueOf(1);
- BigInteger dpId2 = BigInteger.valueOf(2);
+ Uint64 dpId1 = Uint64.ONE;
+ Uint64 dpId2 = Uint64.valueOf(2);
String portName1 = "phy0";
String portName2 = "phy1" ;
int vlanId = 100 ;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.impl;
import static org.mockito.Mockito.doReturn;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class ItmInternalTunnelDeleteTest {
- BigInteger dpId1 = BigInteger.valueOf(1);
- BigInteger dpId2 = BigInteger.valueOf(2);
+ Uint64 dpId1 = Uint64.ONE;
+ Uint64 dpId2 = Uint64.valueOf(2);
int vlanId = 100 ;
int interval = 1000;
String portName1 = "phy0";
InstanceIdentifier.create(TunnelMonitorInterval.class);
Class<? extends TunnelMonitoringTypeBase> monitorProtocol = TunnelMonitoringTypeBfd.class;
InstanceIdentifier<InternalTunnel> internalTunnelIdentifier = InstanceIdentifier.builder(TunnelList.class)
- .child(InternalTunnel.class, new InternalTunnelKey(new BigInteger("1"),
- new BigInteger("2"), tunnelType1)).build();
+ .child(InternalTunnel.class, new InternalTunnelKey(Uint64.ONE, Uint64.valueOf(2), tunnelType1))
+ .build();
@Mock DataBroker dataBroker;
@Mock ReadOnlyTransaction mockReadTx;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class ItmManagerRpcServiceTest {
IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
IpAddress gtwyIp1 = IpAddressBuilder.getDefaultInstance(gwyIp1);
IpPrefix ipPrefixTest = IpPrefixBuilder.getDefaultInstance(subnetIp + "/24");
- BigInteger dpId1 = BigInteger.valueOf(1);
- BigInteger dpId2 = BigInteger.valueOf(2);
+ Uint64 dpId1 = Uint64.ONE;
+ Uint64 dpId2 = Uint64.valueOf(2);
ExternalTunnel externalTunnel = null;
ExternalTunnel externalTunnelNew = null;
InternalTunnel internalTunnel = null;
List<TransportZone> transportZoneList = new ArrayList<>() ;
List<DeviceVteps> deviceVtepsList = new ArrayList<>();
List<String> stringList = new ArrayList<>();
- List<BigInteger> dpId1List = new ArrayList<>();
+ List<Uint64> dpId1List = new ArrayList<>();
DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ipAddress1, sourceDevice);
AddExternalTunnelEndpointInput addExternalTunnelEndpointInput = null;
GetInternalOrExternalInterfaceNameInput getInternalOrExternalInterfaceNameInput = null;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.tests;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class ItmManagerRpcServiceTest {
List<TransportZone> transportZoneList = new ArrayList<>();
List<DeviceVteps> deviceVtepsList = new ArrayList<>();
List<String> stringList = new ArrayList<>();
- List<BigInteger> dpId1List = new ArrayList<>();
+ List<Uint64> dpId1List = new ArrayList<>();
DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ItmTestConstants.IP_ADDRESS_3, ItmTestConstants.SOURCE_DEVICE);
DeviceVtepsKey deviceVtep2Key = new DeviceVtepsKey(ItmTestConstants.IP_ADDRESS_3, ItmTestConstants.SOURCE_DEVICE_2);
AddExternalTunnelEndpointInput addExternalTunnelEndpointInput;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Component tests for ITM TEP Auto Config feature.
.read(LogicalDatastoreType.OPERATIONAL, notHostedPath).checkedGet().get().getUnknownVteps();
//modifing the dpnid and keeping the ip same.
for (UnknownVteps unknownVtep:unknownVtepsList) {
- Vteps vteps = new VtepsBuilder().setDpnId(new BigInteger("10"))
+ Vteps vteps = new VtepsBuilder().setDpnId(Uint64.valueOf(10))
.setIpAddress(unknownVtep.getIpAddress())
- .withKey(new VtepsKey(new BigInteger("10"))).build();
+ .withKey(new VtepsKey(Uint64.valueOf(10))).build();
vtepsList.add(vteps);
}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class ItmTepAutoConfigTestUtil {
private ItmTepAutoConfigTestUtil() {
}
public static InstanceIdentifier<Vteps> getTepIid(IpPrefix subnetMaskObj, String tzName,
- BigInteger dpnId, String portName) {
+ Uint64 dpnId, String portName) {
VtepsKey vtepkey = new VtepsKey(dpnId);
InstanceIdentifier<Vteps> vtepIid = InstanceIdentifier.builder(TransportZones.class)
*/
package org.opendaylight.genius.itm.tests;
-import java.math.BigInteger;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface ItmTestConstants {
String EXT_TUNNEL_INTERFACE_NAME = "tunfdeecc7cb4d";
- BigInteger DP_ID_1 = BigInteger.valueOf(1);
- BigInteger DP_ID_2 = BigInteger.valueOf(2);
+ Uint64 DP_ID_1 = Uint64.ONE;
+ Uint64 DP_ID_2 = Uint64.valueOf(2);
int VLAN_ID = 100 ;
String PORT_NAME_1 = "phy0";
String PARENT_INTERFACE_NAME = "1:phy0:100";
String DEF_BR_NAME = "br-int";
String DEF_BR_DPID = "00:00:00:00:00:00:00:01";
- BigInteger INT_DEF_BR_DPID = BigInteger.valueOf(1);
+ Uint64 INT_DEF_BR_DPID = Uint64.ONE;
String BR2_NAME = "br2";
String BR2_DPID = "00:00:00:00:00:00:00:02";
- BigInteger INT_BR2_DPID = BigInteger.valueOf(2);
+ Uint64 INT_BR2_DPID = Uint64.valueOf(2);
//not hosted tz constants
String NOT_HOSTED_TZ_TEP_IP = "192.168.10.20";
String NOT_HOSTED_TZ_TEPDPN_ID = "0";
- BigInteger NOT_HOSTED_INT_TZ_TEPDPN_ID = BigInteger.valueOf(0);
+ Uint64 NOT_HOSTED_INT_TZ_TEPDPN_ID = Uint64.ZERO;
String NOT_HOSTED_TZ_NAME = "NotHostedTZ";
Boolean OF_TUNNEL = false;
String NOT_HOSTED_DEF_BR_DPID = "00:00:00:00:00:00:00:00";
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.tests.xtend;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
import org.opendaylight.genius.itm.tests.ItmTestConstants;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.itm.tests.xtend;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
import org.opendaylight.genius.itm.tests.ItmTestConstants;
-import org.opendaylight.genius.itm.globals.ITMConstants;
import static extension org.opendaylight.mdsal.binding.testutils.XtendBuilderExtensions.operator_doubleGreaterThan
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
String lockName = input.getLockName();
String owner = lockManagerUtils.getUniqueID();
LOG.debug("Locking {}, owner {}" , lockName, owner);
- long waitTime = input.getTime() == null ? DEFAULT_WAIT_TIME_IN_MILLIS * DEFAULT_RETRY_COUNT : input.getTime();
+ long waitTime = input.getTime() == null ? DEFAULT_WAIT_TIME_IN_MILLIS * DEFAULT_RETRY_COUNT
+ : input.getTime().toJava();
TimeUnit timeUnit = input.getTimeUnit() == null ? TimeUnit.MILLISECONDS
: lockManagerUtils.convertToTimeUnit(input.getTimeUnit());
waitTime = timeUnit.toMillis(waitTime);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
build failure. Please do not modify this unless you have a good reason. -->
<name>ODL :: genius :: ${project.artifactId}</name>
+ <properties>
+ <!-- FIXME: Workaround for https://issues.apache.org/jira/browse/ARIES-1923 -->
+ <maven.compiler.release>10</maven.compiler.release>
+ </properties>
+
<dependencies>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
*/
package org.opendaylight.genius.mdsalutil;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
public abstract class AbstractSwitchEntity {
- public abstract BigInteger getDpnId();
+ public abstract Uint64 getDpnId();
// Force subclasses to implement hashCode() & equals() WITH m_dpnId!
@Override
package org.opendaylight.genius.mdsalutil;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.math.BigInteger;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
import org.immutables.value.Value.Default;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
+import org.opendaylight.yangtools.yang.common.Uint64;
@Immutable
@OpenDaylightImmutableStyle
public abstract class FlowEntity extends AbstractSwitchEntity {
+ protected static final Uint64 DEFAULT_COOKIE = Uint64.valueOf("0110000", 16).intern();
// This is required as it will cause the code generation by @Immutable.org to implement Builder,
// which is required Xtend sources can use the XtendBuilderExtensions.operator_doubleGreaterThan
// This was done because MDSALManager has this hard-coded like this, upon MDSALManager.installFlow()
@Default
- public BigInteger getCookie() {
- return new BigInteger("0110000", 16);
+ public Uint64 getCookie() {
+ return DEFAULT_COOKIE;
}
public abstract String getFlowId();
*/
package org.opendaylight.genius.mdsalutil;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class FlowInfoKey {
- private final BigInteger dpId;
+ private final Uint64 dpId;
private final short tableId;
private final Match matches;
private final String flowId;
- public FlowInfoKey(BigInteger dpId, short tableId, Match matches, String flowId) {
+ public FlowInfoKey(Uint64 dpId, short tableId, Match matches, String flowId) {
this.dpId = dpId;
this.tableId = tableId;
this.matches = matches;
return matches;
}
- public BigInteger getDpId() {
+ public Uint64 getDpId() {
return dpId;
}
*/
package org.opendaylight.genius.mdsalutil;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class GroupInfoKey {
- private final BigInteger dpId;
+ private final Uint64 dpId;
private final long groupId;
- public GroupInfoKey(BigInteger dpId, long groupId) {
+ public GroupInfoKey(Uint64 dpId, long groupId) {
this.dpId = dpId;
this.groupId = groupId;
}
return groupId;
}
- public BigInteger getDpId() {
+ public Uint64 getDpId() {
return dpId;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.mdsalutil;
import com.google.common.base.Optional;
import com.google.common.net.InetAddresses;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
- public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId, int priority,
- String flowName, int idleTimeOut, int hardTimeOut, BigInteger cookie,
+ public static FlowEntity buildFlowEntity(Uint64 dpnId, short tableId, String flowId, int priority,
+ String flowName, int idleTimeOut, int hardTimeOut, Uint64 cookie,
List<? extends MatchInfoBase> listMatchInfoBase, List<InstructionInfo> listInstructionInfo) {
FlowEntityBuilder builder = new FlowEntityBuilder()
// TODO: CHECK IF THIS IS USED
public static Flow buildFlow(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
- int hardTimeOut, BigInteger cookie, List<? extends MatchInfoBase> listMatchInfoBase,
+ int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
List<InstructionInfo> listInstructionInfo) {
- return MDSALUtil.buildFlow(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
+ return buildFlow(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
listMatchInfoBase, listInstructionInfo, true);
}
+ // FIXME: priority -> Uint16
+ // FIXME: tableId -> Uint8
+ // FIXME: idleHardOut -> Uint16
+ // FIXME: idleTiemOut -> Uint16
public static Flow buildFlow(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
- int hardTimeOut, BigInteger cookie, List<? extends MatchInfoBase> listMatchInfoBase,
+ int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
List<InstructionInfo> listInstructionInfo, boolean isStrict) {
FlowKey key = new FlowKey(new FlowId(flowId));
return new FlowBuilder().setMatch(buildMatches(listMatchInfoBase)).withKey(key)
}
public static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
- int hardTimeOut, BigInteger cookie, List<? extends MatchInfoBase> listMatchInfoBase,
+ int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
List<Instruction> listInstructionInfo) {
return MDSALUtil.buildFlowNew(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
listMatchInfoBase, listInstructionInfo, true);
}
private static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
- int hardTimeOut, BigInteger cookie, List<? extends MatchInfoBase> listMatchInfoBase,
+ int hardTimeOut, Uint64 cookie, List<? extends MatchInfoBase> listMatchInfoBase,
List<Instruction> listInstructionInfo, boolean isStrict) {
FlowKey key = new FlowKey(new FlowId(flowId));
return new FlowBuilder().setMatch(buildMatches(listMatchInfoBase)).withKey(key)
.setCookie(new FlowCookie(cookie)).build();
}
- public static GroupEntity buildGroupEntity(BigInteger dpnId, long groupId, String groupName, GroupTypes groupType,
+ public static GroupEntity buildGroupEntity(Uint64 dpnId, long groupId, String groupName, GroupTypes groupType,
List<BucketInfo> listBucketInfo) {
GroupEntityBuilder groupEntity = new GroupEntityBuilder();
}
public static TransmitPacketInput getPacketOutDefault(List<ActionInfo> actionInfos, byte[] payload,
- BigInteger dpnId) {
+ Uint64 dpnId) {
return new TransmitPacketInputBuilder()
.setAction(buildActions(actionInfos))
.setPayload(payload)
.setIngress(ingress).setEgress(ingress).build();
}
- public static TransmitPacketInput getPacketOut(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId,
+ public static TransmitPacketInput getPacketOut(List<ActionInfo> actionInfos, byte[] payload, Uint64 dpnId,
NodeConnectorRef nodeConnRef) {
// TODO Auto-generated method stub
return null;
}
- public static TransmitPacketInput getPacketOut(List<Action> actions, byte[] payload, BigInteger dpnId) {
+ public static TransmitPacketInput getPacketOut(List<Action> actions, byte[] payload, Uint64 dpnId) {
NodeConnectorRef ncRef = getDefaultNodeConnRef(dpnId);
return new TransmitPacketInputBuilder()
.setAction(actions)
.setIngress(ncRef).setEgress(ncRef).build();
}
- public static Action retrieveSetTunnelIdAction(BigInteger tunnelId, int actionKey) {
+ public static Action retrieveSetTunnelIdAction(Uint64 tunnelId, int actionKey) {
return new ActionBuilder().setAction(
new SetFieldCaseBuilder().setSetField(new SetFieldBuilder().setTunnel(new TunnelBuilder()
.setTunnelId(tunnelId).build()).build())
+ (mask == 0 ? "" : "/" + mask);
}
- public static BigInteger getBigIntIpFromIpAddress(IpAddress ipAddr) {
+ public static Uint64 getBigIntIpFromIpAddress(IpAddress ipAddr) {
String ipString = ipAddr.getIpv4Address().getValue();
int ipInt = InetAddresses.coerceToInteger(InetAddresses.forString(ipString));
- return BigInteger.valueOf(ipInt & 0xffffffffL);
+ return Uint64.valueOf(ipInt & 0xffffffffL);
}
}
// TODO: Check the port const
- public static NodeConnectorRef getDefaultNodeConnRef(BigInteger dpId) {
+ public static NodeConnectorRef getDefaultNodeConnRef(Uint64 dpId) {
return getNodeConnRef(NODE_PREFIX + SEPARATOR + dpId, "0xfffffffd");
}
- public static NodeConnectorRef getNodeConnRef(BigInteger dpId, String port) {
+ public static NodeConnectorRef getNodeConnRef(Uint64 dpId, String port) {
return getNodeConnRef(NODE_PREFIX + SEPARATOR + dpId, port);
}
return nodeConnectorRef;
}
- public static BigInteger getDpnIdFromNodeName(NodeId nodeId) {
+ public static Uint64 getDpnIdFromNodeName(NodeId nodeId) {
return getDpnIdFromNodeName(nodeId.getValue());
}
- public static BigInteger getDpnIdFromNodeName(String mdsalNodeName) {
+ public static Uint64 getDpnIdFromNodeName(String mdsalNodeName) {
String dpId = mdsalNodeName.substring(mdsalNodeName.lastIndexOf(':') + 1);
- return new BigInteger(dpId);
+ return Uint64.valueOf(dpId);
}
public static long getOfPortNumberFromPortName(NodeConnectorId nodeConnectorId) {
}
}
- public static BigInteger getDpnId(String datapathId) {
- if (datapathId != null) {
- String dpIdStr = datapathId.replace(":", "");
- BigInteger dpnId = new BigInteger(dpIdStr, 16);
- return dpnId;
- }
- return null;
+ public static Uint64 getDpnId(String datapathId) {
+ return datapathId == null ? null : Uint64.valueOf(datapathId.replace(":", ""), 16);
}
public static Instruction buildAndGetPopVlanActionInstruction(int actionKey, int instructionKey) {
.setEnd(endOffSet)
.build();
nxRegLoadBuilder.setDst(dst);
- nxRegLoadBuilder.setValue(new BigInteger(Long.toString(value)));
+ nxRegLoadBuilder.setValue(Uint64.valueOf(value));
ActionBuilder ab = new ActionBuilder();
ab.setAction(new NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder()
.setNxRegLoad(nxRegLoadBuilder.build()).build());
return buildWriteActionsInstruction(listAction, instructionKey);
}
- public static Instruction buildAndGetWriteMetadaInstruction(BigInteger metadata,
- BigInteger mask, int instructionKey) {
+ public static Instruction buildAndGetWriteMetadaInstruction(Uint64 metadata, Uint64 mask, int instructionKey) {
return new InstructionBuilder()
- .setInstruction(
- new WriteMetadataCaseBuilder().setWriteMetadata(
- new WriteMetadataBuilder().setMetadata(metadata).setMetadataMask(mask).build())
- .build()).withKey(new InstructionKey(instructionKey)).build();
+ .setInstruction(new WriteMetadataCaseBuilder()
+ .setWriteMetadata(new WriteMetadataBuilder()
+ .setMetadata(metadata)
+ .setMetadataMask(mask)
+ .build())
+ .build())
+ .withKey(new InstructionKey(instructionKey)).build();
}
public static Instruction buildAndGetGotoTableInstruction(short tableId, int instructionKey) {
NxRegLoad regLoad = new NxRegLoadBuilder()
.setDst(new DstBuilder().setDstChoice(new DstNxOfInPortCaseBuilder()
.setOfInPort(Empty.getInstance()).build())
- .setStart(0).setEnd(15).build())
- .setValue(BigInteger.valueOf(inPortVal)).build();
+ .setStart(Uint16.ZERO).setEnd(15).build())
+ .setValue(Uint64.valueOf(inPortVal)).build();
ActionBuilder abExt = new ActionBuilder();
abExt.withKey(new ActionKey(actionKey));
abExt.setOrder(actionKey);
*/
package org.opendaylight.genius.mdsalutil;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
public final class MetaDataUtil {
- public static final BigInteger METADATA_MASK_LPORT_TAG = new BigInteger("0FFFFF0000000000", 16);
- public static final BigInteger METADATA_MASK_SERVICE = new BigInteger("000000FFFF000000", 16);
- public static final BigInteger METADATA_MASK_SERVICE_INDEX = new BigInteger("F000000000000000", 16);
- public static final BigInteger METADATA_MASK_VRFID = new BigInteger("0000000000FFFFFE", 16);
- public static final BigInteger METADATA_MASK_REMOTE_ACL_TAG = new BigInteger("0000000000FFFFF0", 16);
- public static final BigInteger METADATA_MASK_POLICY_CLASSIFER_ID = new BigInteger("0000000000FFFFFE", 16);
- public static final BigInteger METADA_MASK_VALID_TUNNEL_ID_BIT_AND_TUNNEL_ID
- = new BigInteger("08000000FFFFFF00", 16);
- public static final BigInteger METADATA_MASK_LABEL_ITM = new BigInteger("40FFFFFF000000FF", 16);
- public static final BigInteger METADA_MASK_TUNNEL_ID = new BigInteger("00000000FFFFFF00", 16);
- public static final BigInteger METADATA_MASK_SERVICE_SH_FLAG = new BigInteger("000000FFFF000001", 16);
- public static final BigInteger METADATA_MASK_LPORT_TAG_SH_FLAG = new BigInteger("0FFFFF0000000001", 16);
- public static final BigInteger METADATA_MASK_SH_FLAG = new BigInteger("0000000000000001", 16);
- public static final BigInteger METADATA_MASK_ELAN_SUBNET_ROUTE = new BigInteger("000000FFFF000000", 16);
- public static final BigInteger METADATA_MASK_SUBNET_ROUTE = new BigInteger("000000FFFFFFFFFE", 16);
- public static final BigInteger METADATA_MASK_ACL_CONNTRACK_CLASSIFIER_TYPE = new BigInteger("0000000000000002", 16);
- public static final BigInteger METADATA_MASK_ACL_DROP = new BigInteger("0000000000000004", 16);
- public static final BigInteger REG6_MASK_REMOTE_DPN = new BigInteger("0FFFFF0000000000", 16);
+ public static final Uint64 METADATA_MASK_LPORT_TAG = Uint64.valueOf("0FFFFF0000000000", 16).intern();
+ public static final Uint64 METADATA_MASK_SERVICE = Uint64.valueOf("000000FFFF000000", 16).intern();
+ public static final Uint64 METADATA_MASK_SERVICE_INDEX = Uint64.valueOf("F000000000000000", 16).intern();
+ public static final Uint64 METADATA_MASK_VRFID = Uint64.valueOf("0000000000FFFFFE", 16).intern();
+ public static final Uint64 METADATA_MASK_REMOTE_ACL_TAG = Uint64.valueOf("0000000000FFFFF0", 16).intern();
+ public static final Uint64 METADATA_MASK_POLICY_CLASSIFER_ID = Uint64.valueOf("0000000000FFFFFE", 16).intern();
+ public static final Uint64 METADA_MASK_VALID_TUNNEL_ID_BIT_AND_TUNNEL_ID = Uint64.valueOf("08000000FFFFFF00", 16)
+ .intern();
+ public static final Uint64 METADATA_MASK_LABEL_ITM = Uint64.valueOf("40FFFFFF000000FF", 16).intern();
+ public static final Uint64 METADA_MASK_TUNNEL_ID = Uint64.valueOf("00000000FFFFFF00", 16).intern();
+ public static final Uint64 METADATA_MASK_SERVICE_SH_FLAG = Uint64.valueOf("000000FFFF000001", 16).intern();
+ public static final Uint64 METADATA_MASK_LPORT_TAG_SH_FLAG = Uint64.valueOf("0FFFFF0000000001", 16).intern();
+ public static final Uint64 METADATA_MASK_SH_FLAG = Uint64.valueOf("0000000000000001", 16).intern();
+ public static final Uint64 METADATA_MASK_ELAN_SUBNET_ROUTE = Uint64.valueOf("000000FFFF000000", 16).intern();
+ public static final Uint64 METADATA_MASK_SUBNET_ROUTE = Uint64.valueOf("000000FFFFFFFFFE", 16).intern();
+ public static final Uint64 METADATA_MASK_ACL_CONNTRACK_CLASSIFIER_TYPE = Uint64.valueOf("0000000000000002", 16)
+ .intern();
+ public static final Uint64 METADATA_MASK_ACL_DROP = Uint64.valueOf("0000000000000004", 16).intern();
+ public static final Uint64 REG6_MASK_REMOTE_DPN = Uint64.valueOf("0FFFFF0000000000", 16).intern();
public static final int METADATA_LPORT_TAG_OFFSET = 40;
public static final int METADATA_LPORT_TAG_BITLEN = 20;
public static final int REG6_START_INDEX = 0;
public static final int REG6_END_INDEX = 31;
+ private static final Uint64 MASK_FOR_DISPATCHER = Uint64.valueOf("FFFFFFFFFFFFFFFE", 16).intern();
+
private MetaDataUtil() {
}
- public static BigInteger getMetaDataForLPortDispatcher(int lportTag, short serviceIndex) {
- return getServiceIndexMetaData(serviceIndex).or(getLportTagMetaData(lportTag));
+ public static Uint64 getMetaDataForLPortDispatcher(int lportTag, short serviceIndex) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(getServiceIndexMetaData(serviceIndex).toJava().or(
+ getLportTagMetaData(lportTag).toJava()));
}
- public static BigInteger getMetaDataForLPortDispatcher(int lportTag, short serviceIndex,
- BigInteger serviceMetaData) {
+ public static Uint64 getMetaDataForLPortDispatcher(int lportTag, short serviceIndex, Uint64 serviceMetaData) {
return getMetaDataForLPortDispatcher(lportTag, serviceIndex, serviceMetaData, false);
}
- public static BigInteger getMetaDataForLPortDispatcher(int lportTag, short serviceIndex,
- BigInteger serviceMetaData, boolean isSHFlagSet) {
- int shBit = isSHFlagSet ? 1 : 0;
- return getServiceIndexMetaData(serviceIndex).or(getLportTagMetaData(lportTag)).or(serviceMetaData)
- .or(BigInteger.valueOf(shBit));
+ public static Uint64 getMetaDataForLPortDispatcher(int lportTag, short serviceIndex,
+ Uint64 serviceMetaData, boolean isSHFlagSet) {
+ return Uint64.fromLongBits(getServiceIndexMetaData(serviceIndex).longValue()
+ | getLportTagMetaData(lportTag).longValue()
+ | serviceMetaData.longValue()
+ | (isSHFlagSet ? 1 : 0));
}
- public static BigInteger getPolicyClassifierMetaData(long classifier) {
- return METADATA_MASK_POLICY_CLASSIFER_ID.and(BigInteger.valueOf(classifier).shiftLeft(1));
+ public static Uint64 getPolicyClassifierMetaData(long classifier) {
+ return Uint64.valueOf((METADATA_MASK_POLICY_CLASSIFER_ID.longValue() & classifier) << 1);
}
- public static BigInteger getServiceIndexMetaData(int serviceIndex) {
- return new BigInteger("F", 16).and(BigInteger.valueOf(serviceIndex)).shiftLeft(60);
+ public static Uint64 getServiceIndexMetaData(int serviceIndex) {
+ return Uint64.fromLongBits((serviceIndex & 0xFL) << 60);
}
- public static BigInteger getLportTagMetaData(int lportTag) {
- return new BigInteger("FFFFF", 16).and(BigInteger.valueOf(lportTag)).shiftLeft(METADATA_LPORT_TAG_OFFSET);
+ public static Uint64 getLportTagMetaData(int lportTag) {
+ return Uint64.fromLongBits((lportTag & 0xFFFFFL) << METADATA_LPORT_TAG_OFFSET);
}
- public static BigInteger getMetaDataMaskForLPortDispatcher() {
+ public static Uint64 getMetaDataMaskForLPortDispatcher() {
return getMetaDataMaskForLPortDispatcher(METADATA_MASK_LPORT_TAG);
}
- public static BigInteger getMetaDataMaskForLPortDispatcher(BigInteger metadataMaskForLPortTag) {
- return METADATA_MASK_SERVICE_INDEX.or(metadataMaskForLPortTag);
+ public static Uint64 getMetaDataMaskForLPortDispatcher(Uint64 metadataMaskForLPortTag) {
+ return Uint64.fromLongBits(METADATA_MASK_SERVICE_INDEX.longValue() | metadataMaskForLPortTag.longValue());
}
- public static BigInteger getMetaDataMaskForLPortDispatcher(BigInteger metadataMaskForServiceIndex,
- BigInteger metadataMaskForLPortTag, BigInteger metadataMaskForService) {
- return metadataMaskForServiceIndex.or(metadataMaskForLPortTag).or(metadataMaskForService);
+ public static Uint64 getMetaDataMaskForLPortDispatcher(Uint64 metadataMaskForServiceIndex,
+ Uint64 metadataMaskForLPortTag, Uint64 metadataMaskForService) {
+ return Uint64.fromLongBits(metadataMaskForServiceIndex.longValue() | metadataMaskForLPortTag.longValue()
+ | metadataMaskForService.longValue());
}
- public static BigInteger getMetadataLPort(int portTag) {
- return new BigInteger("FFFF", 16).and(BigInteger.valueOf(portTag)).shiftLeft(METADATA_LPORT_TAG_OFFSET);
+ public static Uint64 getMetadataLPort(int portTag) {
+ return Uint64.valueOf((portTag & 0xFFFFL) << METADATA_LPORT_TAG_OFFSET);
}
- public static BigInteger getLportFromMetadata(BigInteger metadata) {
- return metadata.and(METADATA_MASK_LPORT_TAG).shiftRight(METADATA_LPORT_TAG_OFFSET);
+ public static Uint64 getLportFromMetadata(Uint64 metadata) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(metadata.toJava().and(METADATA_MASK_LPORT_TAG.toJava())
+ .shiftRight(METADATA_LPORT_TAG_OFFSET));
}
- public static int getElanTagFromMetadata(BigInteger metadata) {
- return metadata.and(MetaDataUtil.METADATA_MASK_SERVICE).shiftRight(24).intValue();
+ public static int getElanTagFromMetadata(Uint64 metadata) {
+ // FIXME: this can be done more efficiently
+ return metadata.toJava().and(MetaDataUtil.METADATA_MASK_SERVICE.toJava()).shiftRight(24).intValue();
}
- public static long getPolicyClassifierFromMetadata(BigInteger metadata) {
- return metadata.and(METADATA_MASK_POLICY_CLASSIFER_ID).shiftRight(1).longValue();
+ public static long getPolicyClassifierFromMetadata(Uint64 metadata) {
+ // FIXME: this can be done more efficiently
+ return metadata.toJava().and(METADATA_MASK_POLICY_CLASSIFER_ID.toJava()).shiftRight(1).longValue();
}
- public static BigInteger getElanTagMetadata(long elanTag) {
- return BigInteger.valueOf(elanTag).shiftLeft(24);
+ public static Uint64 getElanTagMetadata(long elanTag) {
+ return Uint64.fromLongBits(elanTag << 24);
}
- public static int getServiceTagFromMetadata(BigInteger metadata) {
- return metadata.and(MetaDataUtil.METADATA_MASK_SERVICE_INDEX)
+ public static int getServiceTagFromMetadata(Uint64 metadata) {
+ // FIXME: this can be done more efficiently
+ return metadata.toJava().and(MetaDataUtil.METADATA_MASK_SERVICE_INDEX.toJava())
.shiftRight(60).intValue();
}
* should have 08. So, shifting 08 to 7 bytes (56 bits) and the result is OR-ed with
* VNI being shifted to 1 byte.
*/
- public static BigInteger getTunnelIdWithValidVniBitAndVniSet(int vni) {
- return BigInteger.valueOf(0X08).shiftLeft(56).or(BigInteger.valueOf(vni).shiftLeft(8));
+ public static Uint64 getTunnelIdWithValidVniBitAndVniSet(int vni) {
+ return Uint64.valueOf(8L << 56 | vni << 8);
}
- public static long getNatRouterIdFromMetadata(BigInteger metadata) {
+ public static long getNatRouterIdFromMetadata(Uint64 metadata) {
return getVpnIdFromMetadata(metadata);
}
* @param conntrackClassifierType the conntrack classifier flag
* @return the acl conntrack classifier flag from meta data
*/
- public static BigInteger getAclConntrackClassifierTypeFromMetaData(BigInteger conntrackClassifierType) {
- return METADATA_MASK_ACL_CONNTRACK_CLASSIFIER_TYPE.and(conntrackClassifierType.shiftLeft(1));
+ public static Uint64 getAclConntrackClassifierTypeFromMetaData(Uint64 conntrackClassifierType) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(METADATA_MASK_ACL_CONNTRACK_CLASSIFIER_TYPE.toJava().and(conntrackClassifierType.toJava()
+ .shiftLeft(1)));
}
- public static BigInteger getAclDropMetaData(BigInteger dropFlag) {
- return METADATA_MASK_ACL_DROP.and(dropFlag.shiftLeft(2));
+ public static Uint64 getAclDropMetaData(Uint64 dropFlag) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(METADATA_MASK_ACL_DROP.toJava().and(dropFlag.toJava().shiftLeft(2)));
}
- public static BigInteger getVpnIdMetadata(long vrfId) {
- return METADATA_MASK_VRFID.and(BigInteger.valueOf(vrfId).shiftLeft(1));
+ public static Uint64 getVpnIdMetadata(long vrfId) {
+ return Uint64.valueOf(METADATA_MASK_VRFID.longValue() & vrfId << 1);
}
- public static long getVpnIdFromMetadata(BigInteger metadata) {
- return metadata.and(METADATA_MASK_VRFID).shiftRight(1).longValue();
+ public static long getVpnIdFromMetadata(Uint64 metadata) {
+ // FIXME: this can be done more efficiently
+ return metadata.toJava().and(METADATA_MASK_VRFID.toJava()).shiftRight(1).longValue();
}
- public static BigInteger getWriteMetaDataMaskForDispatcherTable() {
- return new BigInteger("FFFFFFFFFFFFFFFE", 16);
+ public static Uint64 getWriteMetaDataMaskForDispatcherTable() {
+ return MASK_FOR_DISPATCHER;
}
- public static BigInteger getWriteMetaDataMaskForEgressDispatcherTable() {
- return new BigInteger("000000FFFFFFFFFE", 16);
+ public static Uint64 getWriteMetaDataMaskForEgressDispatcherTable() {
+ // FIXME: make this an interned constant
+ return Uint64.valueOf("000000FFFFFFFFFE", 16);
}
- public static BigInteger getLportTagForReg6(int lportTag) {
- return new BigInteger("FFFFF", 16).and(BigInteger.valueOf(lportTag)).shiftLeft(8);
+ public static Uint64 getLportTagForReg6(int lportTag) {
+ return Uint64.valueOf((lportTag & 0xFFFFF) << 8);
}
- public static BigInteger getServiceIndexForReg6(int serviceIndex) {
- return new BigInteger("F", 16).and(BigInteger.valueOf(serviceIndex)).shiftLeft(28);
+ public static Uint64 getServiceIndexForReg6(int serviceIndex) {
+ return Uint64.valueOf((0xFL & serviceIndex) << 28);
}
- public static BigInteger getInterfaceTypeForReg6(int tunnelType) {
- return new BigInteger("F", 16).and(BigInteger.valueOf(tunnelType)).shiftLeft(4);
+ public static Uint64 getInterfaceTypeForReg6(int tunnelType) {
+ return Uint64.valueOf((0xF & tunnelType) << 4);
}
public static long getReg6ValueForLPortDispatcher(int lportTag, short serviceIndex) {
- return getServiceIndexForReg6(serviceIndex).or(getLportTagForReg6(lportTag)).longValue();
+ // FIXME: this can be done more efficiently
+ return getServiceIndexForReg6(serviceIndex).toJava().or(getLportTagForReg6(lportTag).toJava()).longValue();
}
/** Utility to fetch the register value for lport dispatcher table.
* and next 4 bits for interface-type
*/
public static long getReg6ValueForLPortDispatcher(int lportTag, short serviceIndex, short interfaceType) {
- return getServiceIndexForReg6(serviceIndex).or(getLportTagForReg6(lportTag)
- .or(getInterfaceTypeForReg6(interfaceType))).longValue();
+ // FIXME: this can be done more efficiently
+ return getServiceIndexForReg6(serviceIndex).toJava().or(getLportTagForReg6(lportTag).toJava()
+ .or(getInterfaceTypeForReg6(interfaceType).toJava())).longValue();
}
public static long getRemoteDpnMetadatForEgressTunnelTable(long remoteDpnId) {
- return new BigInteger("FFFFF", 16).and(BigInteger.valueOf(remoteDpnId)).shiftLeft(8).longValue();
+ return (remoteDpnId & 0xFFFFFF) << 8;
}
public static long getRemoteDpnMaskForEgressTunnelTable() {
- return REG6_MASK_REMOTE_DPN.shiftRight(32).longValue();
+ // FIXME: this can be done more efficiently
+ return REG6_MASK_REMOTE_DPN.toJava().shiftRight(32).longValue();
}
public static long getLportTagMaskForReg6() {
- return METADATA_MASK_LPORT_TAG.shiftRight(32).longValue();
+ // FIXME: this can be done more efficiently
+ return METADATA_MASK_LPORT_TAG.toJava().shiftRight(32).longValue();
}
public static long getElanMaskForReg() {
- return METADATA_MASK_SERVICE.shiftRight(24).longValue();
+ // FIXME: this can be done more efficiently
+ return METADATA_MASK_SERVICE.toJava().shiftRight(24).longValue();
}
public static long getVpnIdMaskForReg() {
- return METADATA_MASK_VRFID.shiftRight(1).longValue();
+ // FIXME: this can be done more efficiently
+ return METADATA_MASK_VRFID.toJava().shiftRight(1).longValue();
}
- public static BigInteger mergeMetadataValues(BigInteger metadata, BigInteger metadata2) {
- return metadata.or(metadata2);
+ public static Uint64 mergeMetadataValues(Uint64 metadata, Uint64 metadata2) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(metadata.toJava().or(metadata2.toJava()));
}
- public static BigInteger mergeMetadataMask(BigInteger mask, BigInteger mask2) {
- return mask.or(mask2);
+ public static Uint64 mergeMetadataMask(Uint64 mask, Uint64 mask2) {
+ // FIXME: this can be done more efficiently
+ return Uint64.valueOf(mask.toJava().or(mask2.toJava()));
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final class NWUtil {
-
private static final Logger LOG = LoggerFactory.getLogger(NWUtil.class);
-
- private static byte[] HIGH_128_BITS = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- private static BigInteger HIGH_128_INT = new BigInteger(HIGH_128_BITS);
+ private static final BigInteger HIGH_128_INT = new BigInteger(new byte[] {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+ });
private NWUtil() {
/**
* Returns the ids of the currently operative DPNs.
*/
- public static List<BigInteger> getOperativeDPNs(DataBroker dataBroker) {
- List<BigInteger> result = new LinkedList<>();
+ public static List<Uint64> getOperativeDPNs(DataBroker dataBroker) {
+ List<Uint64> result = new LinkedList<>();
InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
Optional<Nodes> nodesOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
nodesInstanceIdentifier);
for (Node node : nodesOptional.get().nonnullNode()) {
NodeId nodeId = node.getId();
if (nodeId != null) {
- BigInteger dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId);
+ Uint64 dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId);
result.add(dpnId);
}
}
*/
package org.opendaylight.genius.mdsalutil;
-import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface NwConstants {
String INGRESS_COUNTERS_SERVICE_NAME = "INGRESS_COUNTERS_SERVICE";
String EGRESS_COUNTERS_SERVICE_NAME = "EGRESS_COUNTERS_SERVICE";
- BigInteger COOKIE_IPV6_TABLE = new BigInteger("4000000", 16);
- BigInteger COOKIE_QOS_TABLE = new BigInteger("4000001", 16);
- BigInteger VLAN_TABLE_COOKIE = new BigInteger("8000000", 16);
- BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16);
- BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
- BigInteger COOKIE_VM_FIB_TABLE = new BigInteger("8000003", 16);
- BigInteger COOKIE_DNAT_TABLE = new BigInteger("8000004", 16);
- BigInteger COOKIE_TS_TABLE = new BigInteger("8000005", 16);
- BigInteger COOKIE_SNAT_TABLE = new BigInteger("8000006", 16);
- BigInteger EGRESS_DISPATCHER_TABLE_COOKIE = new BigInteger("8000007", 16);
- BigInteger COOKIE_OUTBOUND_NAPT_TABLE = new BigInteger("8000008", 16);
- BigInteger COOKIE_L3_GW_MAC_TABLE = new BigInteger("8000009", 16);
- BigInteger COOKIE_SUBNET_ROUTE_TABLE_MISS = new BigInteger("8000010", 16);
- BigInteger EGRESS_POLICY_CLASSIFIER_COOKIE = new BigInteger("8000230", 16);
- BigInteger EGRESS_POLICY_ROUTING_COOKIE = new BigInteger("8000231", 16);
- BigInteger COOKIE_VXLAN_TRUNK_L2_TABLE = new BigInteger("1200000", 16);
- BigInteger COOKIE_GRE_TRUNK_L2_TABLE = new BigInteger("1400000", 16);
- BigInteger COOKIE_ELAN_INGRESS_TABLE = new BigInteger("8040000", 16);
- BigInteger TUNNEL_TABLE_COOKIE = new BigInteger("9000000", 16);
- BigInteger COOKIE_ARP_RESPONDER = new BigInteger("8220000", 16);
- BigInteger COOKIE_COE_KUBE_PROXY_TABLE = new BigInteger("8230000", 16);
- BigInteger COOKIE_ITM_EGRESS_TUNNEL_TABLE = new BigInteger("8000000", 16);
+ // FIXME: There are more efficient ways to express these constants
+ Uint64 COOKIE_IPV6_TABLE = Uint64.valueOf("4000000", 16).intern();
+ Uint64 COOKIE_QOS_TABLE = Uint64.valueOf("4000001", 16).intern();
+ Uint64 VLAN_TABLE_COOKIE = Uint64.valueOf("8000000", 16).intern();
+ Uint64 COOKIE_VM_INGRESS_TABLE = Uint64.valueOf("8000001", 16).intern();
+ Uint64 COOKIE_VM_LFIB_TABLE = Uint64.valueOf("8000002", 16).intern();
+ Uint64 COOKIE_VM_FIB_TABLE = Uint64.valueOf("8000003", 16).intern();
+ Uint64 COOKIE_DNAT_TABLE = Uint64.valueOf("8000004", 16).intern();
+ Uint64 COOKIE_TS_TABLE = Uint64.valueOf("8000005", 16).intern();
+ Uint64 COOKIE_SNAT_TABLE = Uint64.valueOf("8000006", 16).intern();
+ Uint64 EGRESS_DISPATCHER_TABLE_COOKIE = Uint64.valueOf("8000007", 16).intern();
+ Uint64 COOKIE_OUTBOUND_NAPT_TABLE = Uint64.valueOf("8000008", 16).intern();
+ Uint64 COOKIE_L3_GW_MAC_TABLE = Uint64.valueOf("8000009", 16).intern();
+ Uint64 COOKIE_SUBNET_ROUTE_TABLE_MISS = Uint64.valueOf("8000010", 16).intern();
+ Uint64 EGRESS_POLICY_CLASSIFIER_COOKIE = Uint64.valueOf("8000230", 16).intern();
+ Uint64 EGRESS_POLICY_ROUTING_COOKIE = Uint64.valueOf("8000231", 16).intern();
+ Uint64 COOKIE_VXLAN_TRUNK_L2_TABLE = Uint64.valueOf("1200000", 16).intern();
+ Uint64 COOKIE_GRE_TRUNK_L2_TABLE = Uint64.valueOf("1400000", 16).intern();
+ Uint64 COOKIE_ELAN_INGRESS_TABLE = Uint64.valueOf("8040000", 16).intern();
+ Uint64 TUNNEL_TABLE_COOKIE = Uint64.valueOf("9000000", 16).intern();
+ Uint64 COOKIE_ARP_RESPONDER = Uint64.valueOf("8220000", 16).intern();
+ Uint64 COOKIE_COE_KUBE_PROXY_TABLE = Uint64.valueOf("8230000", 16).intern();
+ Uint64 COOKIE_ITM_EGRESS_TUNNEL_TABLE = Uint64.valueOf("8000000", 16).intern();
//Table IDs
short VLAN_INTERFACE_INGRESS_TABLE = 0;
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.learn.grouping.NxLearnBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.learn.grouping.nx.learn.FlowMods;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.learn.grouping.nx.learn.FlowModsBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Learn action.
private final int idleTimeout;
private final int hardTimeout;
private final int priority;
- private final BigInteger cookie;
+ private final Uint64 cookie;
private final int flags;
private final short tableId;
private final int finIdleTimeout;
private final int finHardTimeout;
private final List<FlowMod> flowMods = new ArrayList<>();
- public ActionLearn(int idleTimeout, int hardTimeout, int priority, BigInteger cookie, int flags, short tableId,
+ public ActionLearn(int idleTimeout, int hardTimeout, int priority, Uint64 cookie, int flags, short tableId,
int finIdleTimeout, int finHardTimeout, List<FlowMod> flowMods) {
this(0, idleTimeout, hardTimeout, priority, cookie, flags, tableId, finIdleTimeout, finHardTimeout, flowMods);
}
- public ActionLearn(int actionKey, int idleTimeout, int hardTimeout, int priority, BigInteger cookie, int flags,
+ public ActionLearn(int actionKey, int idleTimeout, int hardTimeout, int priority, Uint64 cookie, int flags,
short tableId, int finIdleTimeout, int finHardTimeout, List<FlowMod> flowMods) {
super(actionKey);
this.idleTimeout = idleTimeout;
return priority;
}
- public BigInteger getCookie() {
+ public Uint64 getCookie() {
return cookie;
}
package org.opendaylight.genius.mdsalutil.actions;
import com.google.common.net.InetAddresses;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Load IP Address to SPA (Sender Protocol Address).
.setNxRegLoad(new NxRegLoadBuilder()
.setDst(new DstBuilder()
.setDstChoice(new DstOfArpSpaCaseBuilder().setOfArpSpa(Empty.getInstance()).build())
- .setStart(0)
+ .setStart(Uint16.ZERO)
.setEnd(31)
.build())
- .setValue(BigInteger.valueOf(
+ .setValue(Uint64.valueOf(
InetAddresses.coerceToInteger(InetAddresses.forString(address)) & 0xffffffffL))
.build())
.build())
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Load MAC address to SHA (Sender Hardware Address).
.setNxRegLoad(new NxRegLoadBuilder()
.setDst(new DstBuilder()
.setDstChoice(new DstNxArpShaCaseBuilder().setNxArpSha(Empty.getInstance()).build())
- .setStart(0)
+ .setStart(Uint16.ZERO)
.setEnd(47)
.build())
- .setValue(BigInteger.valueOf(NWUtil.macToLong(address)))
+ .setValue(Uint64.valueOf(NWUtil.macToLong(address)))
.build())
.build())
.withKey(new ActionKey(newActionKey))
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* NX load in port action.
*/
public class ActionNxLoadInPort extends ActionInfo {
- private final BigInteger value;
+ private final Uint64 value;
- public ActionNxLoadInPort(BigInteger value) {
+ public ActionNxLoadInPort(Uint64 value) {
this(0, value);
}
- public ActionNxLoadInPort(int actionKey, BigInteger value) {
+ public ActionNxLoadInPort(int actionKey, Uint64 value) {
super(actionKey);
this.value = value;
}
.setNxRegLoad(new NxRegLoadBuilder()
.setDst(new DstBuilder()
.setDstChoice(new DstNxOfInPortCaseBuilder().setOfInPort(Empty.getInstance()).build())
- .setStart(0)
+ .setStart(Uint16.ZERO)
.setEnd(15)
.build())
.setValue(value)
.build();
}
- public BigInteger getValue() {
+ public Uint64 getValue() {
return value;
}
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* NX load metadata action.
*/
public class ActionNxLoadMetadata extends ActionInfo {
- private final BigInteger value;
+ private final Uint64 value;
private final Integer startBit;
private final Integer endBit;
- public ActionNxLoadMetadata(BigInteger value, Integer startBit, Integer endBit) {
+ public ActionNxLoadMetadata(Uint64 value, Integer startBit, Integer endBit) {
this(0, value, startBit, endBit);
}
- public ActionNxLoadMetadata(int actionKey, BigInteger value, Integer startBit, Integer endBit) {
+ public ActionNxLoadMetadata(int actionKey, Uint64 value, Integer startBit, Integer endBit) {
super(actionKey);
this.value = value;
this.startBit = startBit;
.build();
}
- public BigInteger getValue() {
+ public Uint64 getValue() {
return value;
}
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.Dst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Action to load an NXM register.
.setStart(start)
.setEnd(end)
.build();
- NxRegLoadBuilder nxRegLoadBuilder = new NxRegLoadBuilder().setDst(dst).setValue(BigInteger.valueOf(load));
+ NxRegLoadBuilder nxRegLoadBuilder = new NxRegLoadBuilder().setDst(dst).setValue(Uint64.valueOf(load));
return new ActionBuilder()
.setAction(new NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder().setNxRegLoad(
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Set ARP Operation Type that is Request or Replay.
.setStart(0)
.setEnd(15)
.build())
- .setValue(BigInteger.valueOf(value))
+ .setValue(Uint64.valueOf(value))
.build())
.build())
.withKey(new ActionKey(newActionKey))
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
-
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetFieldBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.MetadataBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class ActionSetFieldMeta extends ActionInfo {
- private final BigInteger metadataValue;
+ private final Uint64 metadataValue;
- public ActionSetFieldMeta(BigInteger metadataValue) {
+ public ActionSetFieldMeta(Uint64 metadataValue) {
this(0, metadataValue);
}
- public ActionSetFieldMeta(int actionKey, BigInteger metadataValue) {
+ public ActionSetFieldMeta(int actionKey, Uint64 metadataValue) {
super(actionKey);
this.metadataValue = metadataValue;
}
- public BigInteger getMetadataValue() {
+ public Uint64 getMetadataValue() {
return metadataValue;
}
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TunnelBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Set tunnel id field action.
*/
public class ActionSetFieldTunnelId extends ActionInfo {
- private final BigInteger tunnelId;
- @Nullable private final BigInteger tunnelMask;
+ private final Uint64 tunnelId;
+ private final @Nullable Uint64 tunnelMask;
- public ActionSetFieldTunnelId(BigInteger tunnelId) {
+ public ActionSetFieldTunnelId(Uint64 tunnelId) {
this(0, tunnelId);
}
- public ActionSetFieldTunnelId(int actionKey, BigInteger tunnelId) {
+ public ActionSetFieldTunnelId(int actionKey, Uint64 tunnelId) {
this(actionKey, tunnelId, null);
}
- public ActionSetFieldTunnelId(BigInteger tunnelId, BigInteger tunnelMask) {
+ public ActionSetFieldTunnelId(Uint64 tunnelId, Uint64 tunnelMask) {
this(0, tunnelId, tunnelMask);
}
- public ActionSetFieldTunnelId(int actionKey, BigInteger tunnelId, BigInteger tunnelMask) {
+ public ActionSetFieldTunnelId(int actionKey, Uint64 tunnelId, Uint64 tunnelMask) {
super(actionKey);
this.tunnelId = tunnelId;
this.tunnelMask = tunnelMask;
.build();
}
- public BigInteger getTunnelId() {
+ public Uint64 getTunnelId() {
return tunnelId;
}
- @Nullable
- public BigInteger getTunnelMask() {
+ public @Nullable Uint64 getTunnelMask() {
return tunnelMask;
}
return "ActionSetFieldTunnelId [tunnelId=" + tunnelId + ", tunnelMask=" + tunnelMask + ", getActionKey()="
+ getActionKey() + "]";
}
-
}
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstNxTunIpv4DstCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.group.buckets.bucket.action.action.NxActionRegLoadNodesNodeGroupBucketsBucketActionsCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.Dst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Set tunnel destination IP action.
*/
public class ActionSetTunnelDestinationIp extends ActionInfo {
+ private static final Dst NX_REGEX_LOAD_DST = new DstBuilder()
+ .setDstChoice(new DstNxTunIpv4DstCaseBuilder().setNxTunIpv4Dst(Empty.getInstance()).build())
+ .setStart(Uint16.ZERO)
+ .setEnd(Uint16.valueOf(31).intern())
+ .build();
+
- private final BigInteger destIp;
+ private final Uint64 destIp;
private final boolean groupBucket;
- public ActionSetTunnelDestinationIp(BigInteger destIp) {
+ public ActionSetTunnelDestinationIp(Uint64 destIp) {
this(0, destIp);
}
this(0, destIp);
}
- public ActionSetTunnelDestinationIp(int actionKey, BigInteger destIp) {
+ public ActionSetTunnelDestinationIp(int actionKey, Uint64 destIp) {
super(actionKey);
this.destIp = destIp;
this.groupBucket = false;
this(actionKey, MDSALUtil.getBigIntIpFromIpAddress(destIp));
}
- public BigInteger getDestIp() {
+ public Uint64 getDestIp() {
return destIp;
}
@Override
public Action buildAction(int newActionKey) {
- NxRegLoadBuilder nxRegLoadBuilder = new NxRegLoadBuilder();
- Dst dst = new DstBuilder()
- .setDstChoice(new DstNxTunIpv4DstCaseBuilder().setNxTunIpv4Dst(Empty.getInstance()).build())
- .setStart(0)
- .setEnd(31)
- .build();
- nxRegLoadBuilder.setDst(dst);
- nxRegLoadBuilder.setValue(destIp);
- ActionBuilder ab = new ActionBuilder();
+ NxRegLoad nxRegLoad = new NxRegLoadBuilder()
+ .setDst(NX_REGEX_LOAD_DST)
+ .setValue(destIp)
+ .build();
+ ActionBuilder ab = new ActionBuilder().withKey(new ActionKey(newActionKey));
if (groupBucket) {
ab.setAction(new NxActionRegLoadNodesNodeGroupBucketsBucketActionsCaseBuilder()
- .setNxRegLoad(nxRegLoadBuilder.build()).build());
+ .setNxRegLoad(nxRegLoad).build());
} else {
ab.setAction(new NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder()
- .setNxRegLoad(nxRegLoadBuilder.build()).build());
+ .setNxRegLoad(nxRegLoad).build());
}
- ab.withKey(new ActionKey(newActionKey));
return ab.build();
}
*/
package org.opendaylight.genius.mdsalutil.actions;
-import java.math.BigInteger;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.MDSALUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstNxTunIpv4SrcCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.group.buckets.bucket.action.action.NxActionRegLoadNodesNodeGroupBucketsBucketActionsCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoadBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.Dst;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.nx.reg.load.DstBuilder;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Set tunnel source IP action.
*/
public class ActionSetTunnelSourceIp extends ActionInfo {
+ private static final Dst NX_REGEX_LOAD_SRC = new DstBuilder()
+ .setDstChoice(new DstNxTunIpv4SrcCaseBuilder().setNxTunIpv4Src(Empty.getInstance()).build())
+ .setStart(Uint16.ZERO)
+ .setEnd(Uint16.valueOf(31).intern())
+ .build();
- private final BigInteger sourceIp;
+ private final Uint64 sourceIp;
private final boolean groupBucket;
- public ActionSetTunnelSourceIp(BigInteger sourceIp) {
+ public ActionSetTunnelSourceIp(Uint64 sourceIp) {
this(0, sourceIp);
}
this(0, sourceIp);
}
- public ActionSetTunnelSourceIp(int actionKey, BigInteger sourceIp) {
+ public ActionSetTunnelSourceIp(int actionKey, Uint64 sourceIp) {
super(actionKey);
this.sourceIp = sourceIp;
this.groupBucket = false;
this(actionKey, MDSALUtil.getBigIntIpFromIpAddress(sourceIp));
}
- public BigInteger getSourceIp() {
+ public Uint64 getSourceIp() {
return sourceIp;
}
@Override
public Action buildAction(int newActionKey) {
- NxRegLoadBuilder nxRegLoadBuilder = new NxRegLoadBuilder();
- Dst dst = new DstBuilder()
- .setDstChoice(new DstNxTunIpv4SrcCaseBuilder().setNxTunIpv4Src(Empty.getInstance()).build())
- .setStart(0)
- .setEnd(31)
- .build();
- nxRegLoadBuilder.setDst(dst);
- nxRegLoadBuilder.setValue(sourceIp);
- ActionBuilder ab = new ActionBuilder();
+ final NxRegLoad nxRegLoad = new NxRegLoadBuilder()
+ .setDst(NX_REGEX_LOAD_SRC)
+ .setValue(sourceIp)
+ .build();
+ ActionBuilder ab = new ActionBuilder().withKey(new ActionKey(newActionKey));
if (groupBucket) {
ab.setAction(new NxActionRegLoadNodesNodeGroupBucketsBucketActionsCaseBuilder()
- .setNxRegLoad(nxRegLoadBuilder.build()).build());
+ .setNxRegLoad(nxRegLoad).build());
} else {
ab.setAction(new NxActionRegLoadNodesNodeTableFlowApplyActionsCaseBuilder()
- .setNxRegLoad(nxRegLoadBuilder.build()).build());
+ .setNxRegLoad(nxRegLoad).build());
}
- ab.withKey(new ActionKey(newActionKey));
return ab.build();
}
*/
package org.opendaylight.genius.mdsalutil.instructions;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadataBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Write metadata instruction.
*/
public class InstructionWriteMetadata extends AbstractInstructionInfoImpl {
+ private final Uint64 metadata;
+ private final Uint64 mask;
- private final BigInteger metadata;
- private final BigInteger mask;
-
- public InstructionWriteMetadata(BigInteger metadata, BigInteger mask) {
+ // FIXME: this should take and WriteMetadata instance
+ public InstructionWriteMetadata(Uint64 metadata, Uint64 mask) {
this.metadata = metadata;
this.mask = mask;
}
.build();
}
- public BigInteger getMetadata() {
+ public Uint64 getMetadata() {
return metadata;
}
- public BigInteger getMask() {
+ public Uint64 getMask() {
return mask;
}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface IMdsalApiManager {
/**
* Adds a flow.
*
- * @deprecated Use {@link #addFlow(TypedWriteTransaction, BigInteger, Flow)}.
+ * @deprecated Use {@link #addFlow(TypedWriteTransaction, Uint64, Flow)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> installFlow(BigInteger dpId, Flow flowEntity);
+ CheckedFuture<Void,TransactionCommitFailedException> installFlow(Uint64 dpId, Flow flowEntity);
/**
* Adds a flow.
* @deprecated Use {@link #addFlow(TypedWriteTransaction, FlowEntity)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> installFlow(BigInteger dpId, FlowEntity flowEntity);
+ CheckedFuture<Void,TransactionCommitFailedException> installFlow(Uint64 dpId, FlowEntity flowEntity);
/**
* Adds the given flow.
* @param dpId The DPN identifier.
* @param flow The flow.
*/
- void addFlow(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow);
+ void addFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow);
/**
* Removes a flow.
*
- * @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, BigInteger, String, short)}.
+ * @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, Uint64, String, short)}.
*/
@Deprecated
- ListenableFuture<Void> removeFlow(BigInteger dpId, short tableId, FlowId flowId);
+ ListenableFuture<Void> removeFlow(Uint64 dpId, short tableId, FlowId flowId);
/**
* Removes a flow.
/**
* Removes a flow.
*
- * @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, BigInteger, Flow)}.
+ * @deprecated Use {@link #removeFlow(TypedReadWriteTransaction, Uint64, Flow)}.
*/
@Deprecated
- CheckedFuture<Void,TransactionCommitFailedException> removeFlow(BigInteger dpId, Flow flowEntity);
+ CheckedFuture<Void,TransactionCommitFailedException> removeFlow(Uint64 dpId, Flow flowEntity);
/**
* Removes the given flow.
* @param dpId The DPN identifier.
* @param flow The flow.
*/
- void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow)
+ void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow)
throws ExecutionException, InterruptedException;
/**
* @param flowKey The flow key.
* @param tableId The table identifier.
*/
- void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, FlowKey flowKey, short tableId)
+ void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, FlowKey flowKey, short tableId)
throws ExecutionException, InterruptedException;
/**
* @param flowId The flow identifier.
* @param tableId The table identifier.
*/
- void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, String flowId, short tableId)
+ void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, String flowId, short tableId)
throws ExecutionException, InterruptedException;
/**
* @param dpId The DPN identifier.
* @param group The group to add.
*/
- void addGroup(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Group group);
+ void addGroup(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Group group);
/**
* Remove a group.
* @param dpId The DPN identifier.
* @param group The group to remove.
*/
- void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Group group)
+ void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Group group)
throws ExecutionException, InterruptedException;
/**
* @param dpId The DPN identifier.
* @param groupId The group identifier of the group to remove.
*/
- void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId)
+ void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId)
throws ExecutionException, InterruptedException;
/**
* @return true if group exists and false otherwise
*/
@Deprecated
- boolean groupExists(BigInteger dpId, long groupId);
+ boolean groupExists(Uint64 dpId, long groupId);
/**
* API to remove the flow on Data Plane Node synchronously. It internally waits for
@Deprecated
void syncRemoveGroup(GroupEntity groupEntity);
- void addBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId, Bucket bucket)
+ void addBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId, Bucket bucket)
throws ExecutionException, InterruptedException;
- void removeBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId, long bucketId)
+ void removeBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId, long bucketId)
throws ExecutionException, InterruptedException;
}
*/
package org.opendaylight.genius.mdsalutil.matches;
-import java.math.BigInteger;
import java.util.Map;
import org.opendaylight.genius.mdsalutil.MatchInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* In port match.
*/
public class MatchInPort extends MatchInfo {
- private final BigInteger dpId;
+ private final Uint64 dpId;
private final long portNumber;
- public MatchInPort(BigInteger dpId, long portNumber) {
+ public MatchInPort(Uint64 dpId, long portNumber) {
this.dpId = dpId;
this.portNumber = portNumber;
}
matchBuilder.setInPort(new NodeConnectorId(nodeConnectorId));
}
- public BigInteger getDpId() {
+ public Uint64 getDpId() {
return dpId;
}
*/
package org.opendaylight.genius.mdsalutil.matches;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Metadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.MetadataBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Metadata match.
*/
public class MatchMetadata extends MatchInfoHelper<Metadata, MetadataBuilder> {
+ // FIXME: just use WriteMetadata
+ private final Uint64 metadata;
+ private final Uint64 mask;
- private final BigInteger metadata;
- private final BigInteger mask;
-
- public MatchMetadata(BigInteger metadata, BigInteger mask) {
+ public MatchMetadata(Uint64 metadata, Uint64 mask) {
this.metadata = metadata;
this.mask = mask;
}
builder.setMetadata(metadata).setMetadataMask(mask);
}
- public BigInteger getMetadata() {
+ public Uint64 getMetadata() {
return metadata;
}
- public BigInteger getMask() {
+ public Uint64 getMask() {
return mask;
}
*/
package org.opendaylight.genius.mdsalutil.matches;
-import java.math.BigInteger;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Tunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.TunnelBuilder;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Tunnel identifier match.
*/
public class MatchTunnelId extends MatchInfoHelper<Tunnel, TunnelBuilder> {
- private final BigInteger tunnelId;
- private final BigInteger tunnelMask;
+ private final Uint64 tunnelId;
+ private final Uint64 tunnelMask;
- public MatchTunnelId(BigInteger tunnelId) {
+ public MatchTunnelId(Uint64 tunnelId) {
this.tunnelId = tunnelId;
this.tunnelMask = null;
}
- public MatchTunnelId(BigInteger tunnelId, BigInteger tunnelMask) {
+ public MatchTunnelId(Uint64 tunnelId, Uint64 tunnelMask) {
this.tunnelId = tunnelId;
this.tunnelMask = tunnelMask;
}
}
}
- public BigInteger getTunnelId() {
+ public Uint64 getTunnelId() {
return tunnelId;
}
- public BigInteger getTunnelMask() {
+ public Uint64 getTunnelMask() {
return tunnelMask;
}
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
pendingModificationByResourceType.get(resoureType).add(iid);
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void afterModification(String resoureType, InstanceIdentifier<?> iid) {
pendingModificationByResourceType.get(resoureType).remove(iid);
}
Action action = actionInfo.buildAction();
assertTrue(action.getAction() instanceof GroupActionCase);
GroupActionCase actionCase = (GroupActionCase) action.getAction();
- assertEquals(123L, (long) actionCase.getGroupAction().getGroupId());
+ assertEquals(123L, actionCase.getGroupAction().getGroupId().toJava());
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.math.BigInteger;
import java.util.Arrays;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionLearnNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.learn.grouping.NxLearn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.learn.grouping.nx.learn.FlowMods;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test class for {@link ActionRegLoad}.
private static final int IDLE_TIMEOUT = 2;
private static final int HARD_TIMEOUT = 3;
private static final int PRIORITY = 4;
- private static final BigInteger COOKIE = BigInteger.valueOf(5);
+ private static final Uint64 COOKIE = Uint64.valueOf(5);
private static final int FLAGS = 6;
private static final short TABLE_ID = (short) 7;
private static final int FIN_IDLE_TIMEOUT = 8;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
import com.google.common.net.InetAddresses;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yangtools.yang.common.Empty;
-
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test for {@link ActionLoadIpToSpa}.
assertEquals(0, nxRegLoad.getDst().getStart().intValue());
assertEquals(31, nxRegLoad.getDst().getEnd().intValue());
assertEquals(
- BigInteger.valueOf(InetAddresses.coerceToInteger(InetAddresses.forString(IP_ADDRESS)) & 0xffffffffL),
+ Uint64.valueOf(InetAddresses.coerceToInteger(InetAddresses.forString(IP_ADDRESS)) & 0xffffffffL),
nxRegLoad.getValue());
}
import static org.junit.Assert.assertTrue;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.ActionInfo;
import org.opendaylight.genius.mdsalutil.NWUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test for {@link ActionLoadMacToSha}.
assertEquals(Empty.getInstance(),dstNxArpShaCase.getNxArpSha());
assertEquals(0, nxRegLoad.getDst().getStart().intValue());
assertEquals(47, nxRegLoad.getDst().getEnd().intValue());
- assertEquals(BigInteger.valueOf(NWUtil.macToLong(new MacAddress(MAC_ADDRESS))), nxRegLoad.getValue());
+ assertEquals(Uint64.valueOf(NWUtil.macToLong(new MacAddress(MAC_ADDRESS))),
+ nxRegLoad.getValue());
}
@Test
import static org.junit.Assert.assertTrue;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.tests.UintXtendBeanGenerator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstNxOfInPortCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test for {@link ActionNxLoadInPort}.
*/
public class ActionNxLoadInPortTest {
- private static final BigInteger VALUE = BigInteger.TEN;
+ private static final Uint64 VALUE = Uint64.valueOf(10).intern();
- private XtendBeanGenerator generator = new XtendBeanGenerator();
+ private final XtendBeanGenerator generator = new UintXtendBeanGenerator();
@Test
public void actionInfoTest() {
public void generateAction() {
ActionInfo actionInfo = new ActionNxLoadInPort(VALUE);
assertEquals(
- "new ActionNxLoadInPort(0, " + VALUE + "bi)", generator.getExpression(actionInfo));
+ "new ActionNxLoadInPort(0, (u64)" + VALUE + ")", generator.getExpression(actionInfo));
}
}
import static org.junit.Assert.assertTrue;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.ActionInfo;
+import org.opendaylight.genius.mdsalutil.tests.UintXtendBeanGenerator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstOfMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test for {@link ActionNxLoadMetadata}.
*/
public class ActionNxLoadMetadataTest {
- private static final BigInteger VALUE = BigInteger.TEN;
+ private static final Uint64 VALUE = Uint64.valueOf(10);
private static final Integer START = 0;
private static final Integer END = 23;
- private XtendBeanGenerator generator = new XtendBeanGenerator();
+ private final XtendBeanGenerator generator = new UintXtendBeanGenerator();
@Test
public void actionInfoTest() {
NxRegLoad nxRegLoad = actionCase.getNxRegLoad();
assertTrue(nxRegLoad.getDst().getDstChoice() instanceof DstOfMetadataCase);
DstOfMetadataCase dstOfMetadataCase = (DstOfMetadataCase) nxRegLoad.getDst().getDstChoice();
- assertEquals(Empty.getInstance(),dstOfMetadataCase.getOfMetadata());
- assertEquals(START, nxRegLoad.getDst().getStart());
- assertEquals(END, nxRegLoad.getDst().getEnd());
+ assertEquals(Empty.getInstance(), dstOfMetadataCase.getOfMetadata());
+ assertEquals(Uint16.valueOf(START), nxRegLoad.getDst().getStart());
+ assertEquals(Uint16.valueOf(END), nxRegLoad.getDst().getEnd());
assertEquals(VALUE, nxRegLoad.getValue());
}
@Test
public void generateAction() {
ActionInfo actionInfo = new ActionNxLoadMetadata(VALUE, START, END);
- assertEquals(
- "new ActionNxLoadMetadata(0, " + VALUE + "bi" + ", " + START + ", " + END + ")", generator
- .getExpression(actionInfo));
+ assertEquals("new ActionNxLoadMetadata(0, (u64)" + VALUE + ", " + START + ", " + END + ")",
+ generator.getExpression(actionInfo));
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstNxRegCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegLoadNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.load.grouping.NxRegLoad;
+import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Test class for {@link ActionRegLoad}.
assertTrue(nxRegLoad.getDst().getDstChoice() instanceof DstNxRegCase);
DstNxRegCase dstNxRegCase = (DstNxRegCase) nxRegLoad.getDst().getDstChoice();
assertEquals(NxmNxReg6.class, dstNxRegCase.getNxReg());
- assertEquals((Integer) 0, nxRegLoad.getDst().getStart());
- assertEquals((Integer) 31, nxRegLoad.getDst().getEnd());
+ assertEquals(Uint16.valueOf(0), nxRegLoad.getDst().getStart());
+ assertEquals(Uint16.valueOf(31), nxRegLoad.getDst().getEnd());
assertEquals(100, nxRegLoad.getValue().longValue());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.dst.choice.grouping.dst.choice.DstOfMplsLabelCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionRegMoveNodesNodeTableFlowApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.reg.move.grouping.NxRegMove;
+import org.opendaylight.yangtools.yang.common.Uint16;
/**
* Test for {@link ActionRegMove}.
= (NxActionRegMoveNodesNodeTableFlowApplyActionsCase) action.getAction();
NxRegMove nxRegMove = actionsCase.getNxRegMove();
assertTrue(nxRegMove.getDst().getDstChoice() instanceof DstOfMplsLabelCase);
- assertEquals((Integer) 0, nxRegMove.getDst().getStart());
- assertEquals((Integer) 31, nxRegMove.getDst().getEnd());
+ assertEquals(Uint16.valueOf(0), nxRegMove.getDst().getStart());
+ assertEquals(Uint16.valueOf(31), nxRegMove.getDst().getEnd());
}
@Test
import static org.junit.Assert.assertTrue;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.InstructionInfo;
+import org.opendaylight.genius.mdsalutil.tests.UintXtendBeanGenerator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadata;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test for {@link InstructionWriteMetadata}.
public class InstructionWriteMetadataTest {
private static final InstructionWriteMetadata INSTRUCTION_INFO
- = new InstructionWriteMetadata(BigInteger.ONE, BigInteger.TEN);
+ = new InstructionWriteMetadata(Uint64.ONE, Uint64.valueOf(10));
@Test
public void newInstruction() {
verifyInstructionInfo(INSTRUCTION_INFO);
}
- private void verifyInstructionInfo(InstructionInfo instructionInfo) {
+ private static void verifyInstructionInfo(InstructionInfo instructionInfo) {
Instruction instruction = instructionInfo.buildInstruction(2);
assertEquals(2, instruction.key().getOrder().intValue());
assertTrue(instruction.getInstruction() instanceof WriteMetadataCase);
WriteMetadataCase writeMetadataCase = (WriteMetadataCase) instruction.getInstruction();
WriteMetadata writeMetadata = writeMetadataCase.getWriteMetadata();
- assertEquals(BigInteger.ONE, writeMetadata.getMetadata());
- assertEquals(BigInteger.TEN, writeMetadata.getMetadataMask());
+ assertEquals(Uint64.ONE, writeMetadata.getMetadata());
+ assertEquals(Uint64.valueOf(10), writeMetadata.getMetadataMask());
}
@Test
public void xtendBeanGenerator() {
- XtendBeanGenerator generator = new XtendBeanGenerator();
- assertEquals("new InstructionWriteMetadata(1bi, 10bi)", generator.getExpression(INSTRUCTION_INFO));
+ XtendBeanGenerator generator = new UintXtendBeanGenerator();
+ assertEquals("new InstructionWriteMetadata((u64)1, (u64)10)", generator.getExpression(INSTRUCTION_INFO));
}
}
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return ImmutableList.copyOf(flows.values());
}
- private synchronized void deleteFlow(BigInteger dpId, String flowId, short tableId) {
+ private synchronized void deleteFlow(Uint64 dpId, String flowId, short tableId) {
flows.remove(new InternalFlowKey(dpId, flowId, tableId));
}
- private synchronized void storeGroup(BigInteger dpnId, Group group) {
- groups.put(new InternalGroupKey(dpnId, group.key().getGroupId().getValue()), group);
+ private synchronized void storeGroup(Uint64 dpnId, Group group) {
+ groups.put(new InternalGroupKey(dpnId, group.key().getGroupId().getValue().toJava()), group);
}
- private synchronized void deleteGroup(BigInteger dpnId, long groupId) {
+ private synchronized void deleteGroup(Uint64 dpnId, long groupId) {
groups.remove(new InternalGroupKey(dpnId, groupId));
}
- private synchronized void storeBucket(BigInteger dpnId, long groupId, Bucket bucket) {
- buckets.put(new InternalBucketKey(dpnId, groupId, bucket.getBucketId().getValue()), bucket);
+ private synchronized void storeBucket(Uint64 dpnId, long groupId, Bucket bucket) {
+ buckets.put(new InternalBucketKey(dpnId, groupId, bucket.getBucketId().getValue().toJava()), bucket);
}
- private synchronized void deleteBucket(BigInteger dpnId, long groupId, long bucketId) {
+ private synchronized void deleteBucket(Uint64 dpnId, long groupId, long bucketId) {
buckets.remove(new InternalBucketKey(dpnId, groupId, bucketId));
}
}
@Override
- public void addFlow(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow) {
+ public void addFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow) {
throw new UnsupportedOperationException("addFlow(..., BigInteger, Flow) isn't supported yet");
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow) {
- removeFlow(tx, dpId, flow.key(), flow.getTableId());
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow) {
+ removeFlow(tx, dpId, flow.key(), flow.getTableId().toJava());
}
@Override
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, FlowKey flowKey,
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, FlowKey flowKey,
short tableId) {
deleteFlow(dpId, flowKey.getId().getValue(), tableId);
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, String flowId,
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, String flowId,
short tableId) {
deleteFlow(dpId, flowId, tableId);
}
}
@Override
- public void addGroup(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Group group) {
+ public void addGroup(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Group group) {
storeGroup(dpId, group);
}
@Override
- public void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Group group) {
- deleteGroup(dpId, group.getGroupId().getValue());
+ public void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Group group) {
+ deleteGroup(dpId, group.getGroupId().getValue().toJava());
}
@Override
- public void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId) {
+ public void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId) {
deleteGroup(dpId, groupId);
}
@Override
- public void addBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId,
+ public void addBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId,
Bucket bucket) {
storeBucket(dpId, groupId, bucket);
}
@Override
- public void removeBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId,
+ public void removeBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId,
long bucketId) {
deleteBucket(dpId, groupId, bucketId);
}
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(BigInteger dpId,
+ public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId,
FlowEntity flowEntity) {
// TODO should dpId be considered here? how? Copy clone FlowEntity and change its dpId?
return installFlow(flowEntity);
}
private static final class InternalFlowKey {
- private final BigInteger dpnId;
+ private final Uint64 dpnId;
private final String flowId;
private final short tableId;
- private InternalFlowKey(BigInteger dpnId, String flowId, short tableId) {
+ private InternalFlowKey(Uint64 dpnId, String flowId, short tableId) {
this.dpnId = dpnId;
this.flowId = flowId;
this.tableId = tableId;
}
private static final class InternalGroupKey {
- private final BigInteger dpnId;
+ private final Uint64 dpnId;
private final long groupId;
- private InternalGroupKey(BigInteger dpnId, long groupId) {
+ private InternalGroupKey(Uint64 dpnId, long groupId) {
this.dpnId = dpnId;
this.groupId = groupId;
}
}
private static final class InternalBucketKey {
- private final BigInteger dpnId;
+ private final Uint64 dpnId;
private final long groupId;
private final long bucketId;
- private InternalBucketKey(BigInteger dpnId, long groupId, long bucketId) {
+ private InternalBucketKey(Uint64 dpnId, long groupId, long bucketId) {
this.dpnId = dpnId;
this.groupId = groupId;
this.bucketId = bucketId;
import com.google.common.collect.ImmutableList;
import com.google.common.testing.EqualsTester;
-import java.math.BigInteger;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
import org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable;
import org.opendaylight.genius.mdsalutil.interfaces.testutils.TestIMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchArpSpa;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Unit test for {@link TestIMdsalApiManager}.
mdsalApiManager.assertFlowsInAnyOrder(ImmutableList.of(getNewFlow2(), getNewFlow1()));
}
- private FlowEntity getNewFlow1() {
+ private static FlowEntity getNewFlow1() {
return new FlowEntityBuilder()
- .setDpnId(BigInteger.valueOf(123))
+ .setDpnId(Uint64.valueOf(123))
.setTableId((short) 1)
- .setCookie(BigInteger.valueOf(456789))
+ .setCookie(Uint64.valueOf(456789))
.setFlowId("ThisIsFlow1")
.setHardTimeOut(456)
.setIdleTimeOut(789)
.build();
}
- private FlowEntity getNewFlow2() {
+ private static FlowEntity getNewFlow2() {
return new FlowEntityBuilder()
- .setDpnId(BigInteger.valueOf(321))
+ .setDpnId(Uint64.valueOf(321))
.setTableId((short) 2)
- .setCookie(BigInteger.valueOf(987654))
+ .setCookie(Uint64.valueOf(987654))
.setFlowId("ThisIsFlow2")
.setHardTimeOut(654)
.setIdleTimeOut(987)
package org.opendaylight.genius.mdsalutil.matches;
import com.google.common.testing.EqualsTester;
-import java.math.BigInteger;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class MatchInPortTest {
}
private MatchInPort newMatchInPort1() {
- return new MatchInPort(BigInteger.ONE, 123);
+ return new MatchInPort(Uint64.ONE, 123);
}
private MatchInPort newMatchInPort2() {
- return new MatchInPort(BigInteger.TEN, 456);
+ return new MatchInPort(Uint64.valueOf(10), 456);
}
}
import static org.junit.Assert.assertEquals;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import java.util.Arrays;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.actions.ActionGroup;
import org.opendaylight.genius.mdsalutil.actions.ActionLearn;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldTunnelId;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Test to check that we no longer need a builder for
*/
public class ActionInfoBuilderTest {
- XtendBeanGenerator generator = new XtendBeanGenerator();
+ XtendBeanGenerator generator = new UintXtendBeanGenerator();
@Test
public void noActionValues() {
@Test
public void set_field_tunnel_idActionWithBigActionValues() {
- ActionInfo actionInfo = new ActionSetFieldTunnelId(BigInteger.valueOf(123));
- assertEquals("new ActionSetFieldTunnelId(0, 123bi)", generator.getExpression(actionInfo));
+ ActionInfo actionInfo = new ActionSetFieldTunnelId(Uint64.valueOf(123));
+ assertEquals("new ActionSetFieldTunnelId(0, (u64)123)", generator.getExpression(actionInfo));
}
@Test
public void set_field_tunnel_idActionWithBigActionValuesWithActionKey() {
- ActionInfo actionInfo = new ActionSetFieldTunnelId(69, BigInteger.valueOf(123));
- assertEquals("new ActionSetFieldTunnelId(69, 123bi)", generator.getExpression(actionInfo));
+ ActionInfo actionInfo = new ActionSetFieldTunnelId(69, Uint64.valueOf(123));
+ assertEquals("new ActionSetFieldTunnelId(69, (u64)123)", generator.getExpression(actionInfo));
}
@Test
@Ignore("Needs to be rewritten")
public void learnActionValuesMatrix() {
- ActionInfo actionInfo = new ActionLearn(1, 2, 3, BigInteger.valueOf(4), 5, (short) 6, 7, 8,
+ ActionInfo actionInfo = new ActionLearn(1, 2, 3, Uint64.valueOf(4), 5, (short) 6, 7, 8,
Arrays.asList(
new ActionLearn.CopyFromValue(2, 3, 4),
new ActionLearn.OutputToPort(4, 5)));
import static org.junit.Assert.assertEquals;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
import org.opendaylight.genius.mdsalutil.actions.ActionNxConntrack;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
+import org.opendaylight.yangtools.yang.common.Uint64;
public class ActionInfoImmutableTest {
@Test
public void actionInfoActionKeyDoesNotMagicallyChangeOnFlowEntityGetFlowBuilder() {
FlowEntityBuilder flowEntityBuilder = new FlowEntityBuilder()
- .setDpnId(BigInteger.valueOf(123L))
+ .setDpnId(Uint64.valueOf(123L))
.setTableId((short) 1)
.setPriority(2)
.setFlowName("TEST-NAME")
.setFlowId("TEST-ID")
- .setCookie(BigInteger.valueOf(110100480L));
+ .setCookie(Uint64.valueOf(110100480L));
ActionInfo actionInfo = new ActionNxConntrack(27, 1, 0, 0, (short) 255);
List<ActionInfo> actionInfos = new ArrayList<>();
actionInfos.add(actionInfo);
@Test
public void testDefaultCookie() {
- assertEquals(new BigInteger("0110000", 16), new FlowEntityBuilder()
- .setDpnId(BigInteger.valueOf(123L))
+ assertEquals(Uint64.valueOf("0110000", 16), new FlowEntityBuilder()
+ .setDpnId(Uint64.valueOf(123L))
.setTableId((short) 1)
.setPriority(2)
.setFlowName("TEST-NAME")
import static org.opendaylight.mdsal.binding.testutils.AssertDataObjects.assertEqualBeans;
import ch.vorburger.xtendbeans.XtendBeanGenerator;
-import java.math.BigInteger;
import org.junit.ComparisonFailure;
import org.junit.Test;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
import org.opendaylight.genius.mdsalutil.matches.MatchIpv4Source;
+import org.opendaylight.yangtools.yang.common.Uint64;
/**
* Tests non-regression of FlowEntity related assertions.
// FLOW1 & FLOW2 differ by a minor variance in their MatchIpv4Source (NB .1 vs .2)
private static final FlowEntity FLOW1 = new FlowEntityBuilder()
.addMatchInfoList(new MatchIpv4Source("10.0.0.1", "32")).setFlowId("A").setTableId((short) 1)
- .setDpnId(BigInteger.ONE).build();
+ .setDpnId(Uint64.ONE).build();
private static final FlowEntity FLOW2 = new FlowEntityBuilder()
.addMatchInfoList(new MatchIpv4Source("10.0.0.2", "32")).setFlowId("A").setTableId((short) 1)
- .setDpnId(BigInteger.ONE).build();
+ .setDpnId(Uint64.ONE).build();
@Test(expected = ComparisonFailure.class)
public void testFlowEntityAssertEqualBeans() {
@Test
public void testXtendBeanGenerator() {
- XtendBeanGenerator generator = new XtendBeanGenerator();
+ XtendBeanGenerator generator = new UintXtendBeanGenerator();
assertThat(generator.getExpression(FLOW1)).isEqualTo("(new FlowEntityBuilder => [\n"
- + " cookie = 1114112bi\n"
- + " dpnId = 1bi\n"
+ + " cookie = (u64)1114112\n"
+ + " dpnId = (u64)1\n"
+ " flowId = \"A\"\n"
+ " hardTimeOut = 0\n"
+ " idleTimeOut = 0\n"
--- /dev/null
+/*
+ * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.mdsalutil.tests;
+
+import ch.vorburger.xtendbeans.XtendBeanGenerator;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.common.Uint8;
+
+public class UintXtendBeanGenerator extends XtendBeanGenerator {
+ @Override
+ protected CharSequence stringify(Object object) {
+ if (object instanceof Uint8) {
+ return "(u8)" + object;
+ } else if (object instanceof Uint16) {
+ return "(u16)" + object;
+ } else if (object instanceof Uint32) {
+ return "(u32)" + object;
+ } else if (object instanceof Uint64) {
+ return "(u64)" + object;
+ } else {
+ return super.stringify(object);
+ }
+ }
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
@RunWith(MockitoJUnitRunner.class)
public class MdSalUtilTest extends AbstractConcurrentDataBrokerTest {
// Methods to test the install Flow and Group
public FlowEntity createFlowEntity(String dpnId, String tableId) {
- BigInteger dpId;
+ Uint64 dpId;
final int serviceId = 0;
List<ActionInfo> listActionInfo = new ArrayList<>();
listActionInfo.add(new ActionPuntToController());
- dpId = new BigInteger(dpnId.split(":")[1]);
+ dpId = Uint64.valueOf(dpnId.split(":")[1]);
List<MatchInfo> mkMatches = new ArrayList<>();
final BigInteger cookie = new BigInteger("9000000", 16);
short shortTableId = Short.parseShort(tableId);
- mkMatches.add(new MatchTunnelId(new BigInteger("0000000000000000", 16)));
+ mkMatches.add(new MatchTunnelId(Uint64.ZERO));
List<InstructionInfo> mkInstructions = new ArrayList<>();
mkInstructions.add(new InstructionWriteActions(listActionInfo));
FlowEntity terminatingServiceTableFlowEntity = MDSALUtil.buildFlowEntity(dpId, shortTableId,
getFlowRef(shortTableId, serviceId), 5, "Terminating Service Flow Entry: " + serviceId, 0, 0,
- cookie.add(BigInteger.valueOf(serviceId)), null, null);
+ Uint64.valueOf(cookie.add(BigInteger.valueOf(serviceId))), null, null);
return terminatingServiceTableFlowEntity;
}
listBucketInfo.add(new BucketInfo(listActionInfo));
String groupName = "Test Group";
- BigInteger dpnId = new BigInteger(nodeid.split(":")[1]);
+ Uint64 dpnId = Uint64.valueOf(nodeid.split(":")[1]);
long id = getUniqueValue(nodeid, inport);
return MDSALUtil.buildGroupEntity(dpnId, id, groupName, GroupTypes.GroupIndirect, listBucketInfo);
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.math.BigInteger;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
tx -> writeFlowEntityInternal(flowEntity, tx)));
}
- private FluentFuture<Void> installFlowInternal(BigInteger dpId, Flow flow) {
+ private FluentFuture<Void> installFlowInternal(Uint64 dpId, Flow flow) {
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> writeFlowInternal(dpId, flow, tx));
}
tx.put(flowInstanceId, flowbld.build(), true);
}
- private static void writeFlowInternal(BigInteger dpId, Flow flow,
+ private static void writeFlowInternal(Uint64 dpId, Flow flow,
TypedWriteTransaction<Datastore.Configuration> tx) {
FlowKey flowKey = new FlowKey(new FlowId(flow.getId()));
- InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, flow.getTableId(), flowKey);
+ InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId,
+ flow.getTableId().toJava(), flowKey);
tx.put(flowInstanceId, flow, true);
}
}
private void deleteFlowEntityInternal(FlowEntity flowEntity, TypedWriteTransaction<Datastore.Configuration> tx) {
- BigInteger dpId = flowEntity.getDpnId();
+ Uint64 dpId = flowEntity.getDpnId();
short tableId = flowEntity.getTableId();
FlowKey flowKey = new FlowKey(new FlowId(flowEntity.getFlowId()));
deleteFlow(dpId, tableId, flowKey, tx);
}
- private void deleteFlow(BigInteger dpId, short tableId, FlowKey flowKey, WriteTransaction tx) {
+ private void deleteFlow(Uint64 dpId, short tableId, FlowKey flowKey, WriteTransaction tx) {
if (flowExists(dpId, tableId, flowKey)) {
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, tableId, flowKey);
tx.delete(LogicalDatastoreType.CONFIGURATION, flowInstanceId);
}
}
- private void deleteFlow(BigInteger dpId, short tableId, FlowKey flowKey,
+ private void deleteFlow(Uint64 dpId, short tableId, FlowKey flowKey,
TypedWriteTransaction<Datastore.Configuration> tx) {
if (flowExists(dpId, tableId, flowKey)) {
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, tableId, flowKey);
}
}
- private FluentFuture<Void> removeFlowNewInternal(BigInteger dpnId, Flow flowEntity) {
+ private FluentFuture<Void> removeFlowNewInternal(Uint64 dpnId, Flow flowEntity) {
LOG.debug("Remove flow {}", flowEntity);
return txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> {
FlowKey flowKey = new FlowKey(flowEntity.getId());
- short tableId = flowEntity.getTableId();
+ short tableId = flowEntity.getTableId().toJava();
deleteFlow(dpnId, tableId, flowKey, tx);
});
}
@VisibleForTesting
- FluentFuture<Void> removeGroupInternal(BigInteger dpnId, long groupId) {
+ FluentFuture<Void> removeGroupInternal(Uint64 dpnId, long groupId) {
return addCallBackForInstallGroupAndReturn(txRunner
.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
tx -> removeGroupInternal(dpnId, groupId, tx)));
}
- private void removeGroupInternal(BigInteger dpnId, long groupId,
+ private void removeGroupInternal(Uint64 dpnId, long groupId,
TypedWriteTransaction<Datastore.Configuration> tx) {
Node nodeDpn = buildDpnNode(dpnId);
if (groupExists(nodeDpn, groupId)) {
}
}
- private static Node buildDpnNode(BigInteger dpnId) {
+ private static Node buildDpnNode(Uint64 dpnId) {
NodeId nodeId = new NodeId("openflow:" + dpnId);
Node nodeDpn = new NodeBuilder().setId(nodeId).withKey(new NodeKey(nodeId)).build();
return nodeDpn;
}
- private static String getGroupKey(long groupId, BigInteger dpId) {
+ private static String getGroupKey(long groupId, Uint64 dpId) {
String synchronizingKey = "group-key-" + groupId + dpId;
return synchronizingKey.intern();
}
- private static String getFlowKey(BigInteger dpId, short tableId, FlowKey flowKey) {
+ private static String getFlowKey(Uint64 dpId, short tableId, FlowKey flowKey) {
String synchronizingKey = "flow-key-" + dpId + tableId + flowKey;
return synchronizingKey.intern();
}
Flow flow = flowEntity.getFlowBuilder().build();
String flowId = flowEntity.getFlowId();
short tableId = flowEntity.getTableId();
- BigInteger dpId = flowEntity.getDpnId();
+ Uint64 dpId = flowEntity.getDpnId();
FlowKey flowKey = new FlowKey(new FlowId(flowId));
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, tableId, flowKey);
LOG.trace("syncSetUpGroup for groupEntity {} ", groupEntity);
}
Group group = groupEntity.getGroupBuilder().build();
- BigInteger dpId = groupEntity.getDpnId();
+ Uint64 dpId = groupEntity.getDpnId();
long groupId = groupEntity.getGroupId();
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupId, buildDpnNode(dpId));
@Override
protected void remove(InstanceIdentifier<Group> identifier, Group del) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, del);
}
- private void executeNotifyTaskIfRequired(BigInteger dpId, Group group) {
- GroupInfoKey groupKey = new GroupInfoKey(dpId, group.getGroupId().getValue());
+ private void executeNotifyTaskIfRequired(Uint64 dpId, Group group) {
+ GroupInfoKey groupKey = new GroupInfoKey(dpId, group.getGroupId().getValue().toJava());
Runnable notifyTask = groupMap.remove(groupKey);
if (notifyTask == null) {
return;
@Override
protected void update(InstanceIdentifier<Group> identifier, Group original, Group update) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, update);
}
@Override
protected void add(InstanceIdentifier<Group> identifier, Group add) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
executeNotifyTaskIfRequired(dpId, add);
}
@Override
protected void remove(InstanceIdentifier<Flow> identifier, Flow del) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
notifyTaskIfRequired(dpId, del);
}
- private void notifyTaskIfRequired(BigInteger dpId, Flow flow) {
- FlowInfoKey flowKey = new FlowInfoKey(dpId, flow.getTableId(), flow.getMatch(), flow.getId().getValue());
+ private void notifyTaskIfRequired(Uint64 dpId, Flow flow) {
+ FlowInfoKey flowKey = new FlowInfoKey(dpId, flow.getTableId().toJava(),
+ flow.getMatch(), flow.getId().getValue());
Runnable notifyTask = flowMap.remove(flowKey);
if (notifyTask == null) {
return;
@Override
protected void add(InstanceIdentifier<Flow> identifier, Flow add) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
notifyTaskIfRequired(dpId, add);
}
@Override
protected void remove(InstanceIdentifier<Flow> identifier, Flow del) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
flowLog.trace("FlowId {} deleted from Table {} on DPN {}",
del.getId().getValue(), del.getTableId(), dpId);
}
@Override
protected void add(InstanceIdentifier<Flow> identifier, Flow add) {
- BigInteger dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
+ Uint64 dpId = getDpnFromString(identifier.firstKeyOf(Node.class).getId().getValue());
flowLog.debug("FlowId {} added to Table {} on DPN {}",
add.getId().getValue(), add.getTableId(), dpId);
}
}
}
- private static BigInteger getDpnFromString(String dpnString) {
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static Uint64 getDpnFromString(String dpnString) {
String[] split = dpnString.split(":");
- return new BigInteger(split[1]);
+ return Uint64.valueOf(split[1]);
}
@Override
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(BigInteger dpId, Flow flowEntity) {
+ public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId, Flow flowEntity) {
return Futures.makeChecked(installFlowInternal(dpId, flowEntity),
t -> new TransactionCommitFailedException("installFlow failed", t));
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> installFlow(BigInteger dpId, FlowEntity flowEntity) {
+ public CheckedFuture<Void, TransactionCommitFailedException> installFlow(Uint64 dpId, FlowEntity flowEntity) {
return Futures.makeChecked(installFlowInternal(dpId, flowEntity.getFlowBuilder().build()),
t -> new TransactionCommitFailedException("installFlow failed", t));
}
@Override
- public ListenableFuture<Void> removeFlow(BigInteger dpId, short tableId, FlowId flowId) {
+ public ListenableFuture<Void> removeFlow(Uint64 dpId, short tableId, FlowId flowId) {
ListenableFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(
tx -> deleteFlow(dpId, tableId, new FlowKey(flowId), tx));
}
@Override
- public CheckedFuture<Void, TransactionCommitFailedException> removeFlow(BigInteger dpId, Flow flowEntity) {
+ public CheckedFuture<Void, TransactionCommitFailedException> removeFlow(Uint64 dpId, Flow flowEntity) {
return Futures.makeChecked(removeFlowNewInternal(dpId, flowEntity),
t -> new TransactionCommitFailedException("removeFlow failed", t));
}
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow)
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow)
throws ExecutionException, InterruptedException {
- removeFlow(tx, dpId, flow.key(), flow.getTableId());
+ removeFlow(tx, dpId, flow.key(), flow.getTableId().toJava());
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, String flowId, short tableId)
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, String flowId, short tableId)
throws ExecutionException, InterruptedException {
removeFlow(tx, dpId, new FlowKey(new FlowId(flowId)), tableId);
}
@Override
- public void removeFlow(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, FlowKey flowKey,
+ public void removeFlow(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, FlowKey flowKey,
short tableId) throws ExecutionException, InterruptedException {
InstanceIdentifier<Flow> flowInstanceIdentifier = buildFlowInstanceIdentifier(dpId, tableId, flowKey);
if (tx.read(flowInstanceIdentifier).get().isPresent()) {
}
@Override
- public void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, Group group)
+ public void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, Group group)
throws ExecutionException, InterruptedException {
- removeGroup(tx, dpId, group.getGroupId().getValue());
+ removeGroup(tx, dpId, group.getGroupId().getValue().toJava());
}
@Override
- public void removeGroup(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId)
+ public void removeGroup(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId)
throws ExecutionException, InterruptedException {
Node nodeDpn = buildDpnNode(dpId);
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupId, nodeDpn);
}
@Override
- public void addFlow(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Flow flow) {
- InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, flow.getTableId(), flow.key());
+ public void addFlow(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Flow flow) {
+ InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId,
+ flow.getTableId().toJava(), flow.key());
tx.put(flowInstanceId, flow, CREATE_MISSING_PARENTS);
}
}
@Override
- public void addGroup(TypedWriteTransaction<Configuration> tx, BigInteger dpId, Group group) {
+ public void addGroup(TypedWriteTransaction<Configuration> tx, Uint64 dpId, Group group) {
Node nodeDpn = buildDpnNode(dpId);
- long groupId = group.getGroupId().getValue();
+ long groupId = group.getGroupId().getValue().toJava();
InstanceIdentifier<Group> groupInstanceId = buildGroupInstanceIdentifier(groupId, nodeDpn);
tx.put(groupInstanceId, group, CREATE_MISSING_PARENTS);
}
@Override
- public void addBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId, Bucket bucket)
+ public void addBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId, Bucket bucket)
throws ExecutionException, InterruptedException {
Node nodeDpn = buildDpnNode(dpId);
if (groupExists(tx, nodeDpn, groupId)) {
InstanceIdentifier<Bucket> bucketInstanceId = buildBucketInstanceIdentifier(groupId,
- bucket.getBucketId().getValue(), nodeDpn);
+ bucket.getBucketId().getValue().toJava(), nodeDpn);
tx.put(bucketInstanceId, bucket);
}
}
@Override
- public void removeBucket(TypedReadWriteTransaction<Configuration> tx, BigInteger dpId, long groupId, long bucketId)
+ public void removeBucket(TypedReadWriteTransaction<Configuration> tx, Uint64 dpId, long groupId, long bucketId)
throws ExecutionException, InterruptedException {
Node nodeDpn = buildDpnNode(dpId);
if (groupExists(tx, nodeDpn, groupId)) {
}
@Override
- public boolean groupExists(BigInteger dpId, long groupId) {
+ public boolean groupExists(Uint64 dpId, long groupId) {
return groupExists(buildDpnNode(dpId), groupId);
}
return groupInstanceId;
}
- private boolean flowExists(BigInteger dpId, short tableId, FlowKey flowKey) {
+ private boolean flowExists(Uint64 dpId, short tableId, FlowKey flowKey) {
InstanceIdentifier<Flow> flowInstanceId = buildFlowInstanceIdentifier(dpId, tableId, flowKey);
try {
Optional<Flow> flowOptional = singleTxDb.syncReadOptional(LogicalDatastoreType.CONFIGURATION,
return false;
}
- private static InstanceIdentifier<Flow> buildFlowInstanceIdentifier(BigInteger dpnId, short tableId,
+ private static InstanceIdentifier<Flow> buildFlowInstanceIdentifier(Uint64 dpnId, short tableId,
FlowKey flowKey) {
InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, buildDpnNode(dpnId).key()).augmentation(FlowCapableNode.class)
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
this.submitAndThrowException = true;
}
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private FluentFuture<? extends CommitInfo> handleCommit(Supplier<FluentFuture<? extends CommitInfo>> commitMethod) {
if (howManyFailingSubmits.decrementAndGet() == -1) {
submitException = null;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
build failure. Please do not modify this unless you have a good reason. -->
<name>ODL :: genius :: ${project.artifactId}</name>
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>com.google.inject</groupId>
+ <artifactId>guice</artifactId>
+ <version>4.2.2</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
<dependencies>
<dependency>
<groupId>org.apache.aries.blueprint</groupId>
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.genius.networkutils;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
+import org.opendaylight.yangtools.yang.common.Uint64;
public interface VniUtils {
- BigInteger getVNI(String vniKey) throws ExecutionException, InterruptedException;
+ @Nullable Uint64 getVNI(String vniKey) throws ExecutionException, InterruptedException;
void releaseVNI(String vniKey) throws ExecutionException, InterruptedException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.networkutils.config.rev181129.NetworkConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
long baseAsNum = Long.parseLong(configureRDSplit[0]);
long baseValue = Long.parseLong(configureRDSplit[1]);
- baseAsNum = baseAsNum + ((baseValue + idValue) / NwConstants.RD_MAX_VALUE_FIELD) ;
+ baseAsNum = baseAsNum + (baseValue + idValue) / NwConstants.RD_MAX_VALUE_FIELD ;
baseValue = (baseValue + idValue) % NwConstants.RD_MAX_VALUE_FIELD ;
return String.valueOf(baseAsNum) + ":" + String.valueOf(baseValue);
Future<RpcResult<AllocateIdOutput>> result = idManagerService.allocateId(getIdInput);
RpcResult<AllocateIdOutput> rpcResult = result.get();
if (rpcResult.isSuccessful()) {
- String rd = convertIdValuetoRD(rpcResult.getResult().getIdValue());
+ String rd = convertIdValuetoRD(rpcResult.getResult().getIdValue().toJava());
return rd;
}
return null;
}
}
+ @Override
public Optional<IdPool> getRDPool() throws ReadFailedException {
return SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, buildIdPoolInstanceIdentifier(NwConstants.ODL_RD_POOL_NAME));
private void validateAndCreateRDPool() throws ReadFailedException {
long lowLimit = 0L;
- long highLimit = networkConfig.getOpendaylightRdCount();
+ Uint32 highConfig = networkConfig.getOpendaylightRdCount();
+ long highLimit = highConfig == null ? 0 : highConfig.toJava();
if (highLimit == 0L) {
highLimit = NwConstants.RD_DEFAULT_COUNT;
}
buildIdPoolInstanceIdentifier(NwConstants.ODL_RD_POOL_NAME));
if (existingIdPool.isPresent()) {
IdPool odlRDPool = existingIdPool.get();
- long currentStartLimit = odlRDPool.getAvailableIdsHolder().getStart();
- long currentEndLimit = odlRDPool.getAvailableIdsHolder().getEnd();
+ long currentStartLimit = odlRDPool.getAvailableIdsHolder().getStart().toJava();
+ long currentEndLimit = odlRDPool.getAvailableIdsHolder().getEnd().toJava();
if (lowLimit == currentStartLimit && highLimit == currentEndLimit) {
LOG.debug("validateAndCreateRDPool : OpenDaylight RD pool already exists "
InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
return idPoolBuilder.build();
}
-}
\ No newline at end of file
+}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.apache.aries.blueprint.annotation.service.Reference;
import org.apache.aries.blueprint.annotation.service.Service;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.networkutils.config.rev181129.NetworkConfig;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public BigInteger getVNI(String vniKey) throws ExecutionException, InterruptedException {
+ public Uint64 getVNI(String vniKey) throws ExecutionException, InterruptedException {
AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(NwConstants.ODL_VNI_POOL_NAME)
.setIdKey(vniKey).build();
Future<RpcResult<AllocateIdOutput>> result = idManagerService.allocateId(getIdInput);
RpcResult<AllocateIdOutput> rpcResult = result.get();
- if (rpcResult.isSuccessful()) {
- return BigInteger.valueOf(rpcResult.getResult().getIdValue());
- }
- return BigInteger.valueOf(-1);
+
+ return rpcResult.isSuccessful() ? Uint64.valueOf(rpcResult.getResult().getIdValue()) : null;
}
@Override
}
}
+ @Override
public Optional<IdPool> getVxlanVniPool() throws ReadFailedException {
return SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, buildIdPoolInstanceIdentifier(NwConstants.ODL_VNI_POOL_NAME));
buildIdPoolInstanceIdentifier(NwConstants.ODL_VNI_POOL_NAME));
if (existingIdPool.isPresent()) {
IdPool odlVniIdPool = existingIdPool.get();
- long currentStartLimit = odlVniIdPool.getAvailableIdsHolder().getStart();
- long currentEndLimit = odlVniIdPool.getAvailableIdsHolder().getEnd();
+ long currentStartLimit = odlVniIdPool.getAvailableIdsHolder().getStart().toJava();
+ long currentEndLimit = odlVniIdPool.getAvailableIdsHolder().getEnd().toJava();
if (lowLimit == currentStartLimit && highLimit == currentEndLimit) {
LOG.debug("validateAndCreateVxlanVniPool : OpenDaylight VXLAN VNI range pool already exists "
InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
return idPoolBuilder.build();
}
-}
\ No newline at end of file
+}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>5.0.2</version>
+ <version>6.0.0</version>
<relativePath/>
</parent>
Code Review / genius.git / commitdiff