Migrate to use MD-SAL APIs instead of deprecated Controller APIs.
Change-Id: I642d319c8cddf958ac44cad328d99fdd1e1270e9
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
<artifactId>netty-event-executor-config</artifactId>
<version>${config.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- <version>${mdsal.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<artifactId>junit-addons</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- <version>1.10.0-SNAPSHOT</version>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
*/
package org.opendaylight.lispflowmapping.dsbackend;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
InstanceIdentifier.create(MappingDatabase.class);
private static final InstanceIdentifier<LastUpdated> LAST_UPDATED =
InstanceIdentifier.create(MappingDatabase.class).child(LastUpdated.class);
- private DataBroker broker;
- private BindingTransactionChain txChain;
+ private final DataBroker broker;
+ private TransactionChain txChain;
public DataStoreBackEnd(DataBroker broker) {
this.broker = broker;
public void createTransactionChain() {
LOG.debug("Creating DataStoreBackEnd transaction chain...");
- txChain = broker.createTransactionChain(this);
+ txChain = broker.createMergingTransactionChain(this);
}
public void addAuthenticationKey(AuthenticationKey authenticationKey) {
public List<Mapping> getAllMappings(LogicalDatastoreType logicalDataStore) {
LOG.debug("MD-SAL: Get all mappings from {} datastore",
logicalDataStore == LogicalDatastoreType.CONFIGURATION ? "config" : "operational");
- List<Mapping> mappings = new ArrayList<Mapping>();
+ List<Mapping> mappings = new ArrayList<>();
MappingDatabase mdb = readTransaction(DATABASE_ROOT, logicalDataStore);
if (mdb != null && mdb.getVirtualNetworkIdentifier() != null) {
public List<AuthenticationKey> getAllAuthenticationKeys() {
LOG.debug("MD-SAL: Get all authentication keys from datastore");
- List<AuthenticationKey> authKeys = new ArrayList<AuthenticationKey>();
+ List<AuthenticationKey> authKeys = new ArrayList<>();
MappingDatabase mdb = readTransaction(DATABASE_ROOT, LogicalDatastoreType.CONFIGURATION);
if (mdb != null && mdb.getVirtualNetworkIdentifier() != null) {
InstanceIdentifier<U> addIID, U data, LogicalDatastoreType logicalDatastoreType, String errMsg) {
WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
writeTx.put(logicalDatastoreType, addIID, data, true);
- Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() {
+ writeTx.commit().addCallback(new FutureCallback<CommitInfo>() {
- public void onSuccess(Void result) {
+ @Override
+ public void onSuccess(CommitInfo result) {
}
+ @Override
public void onFailure(Throwable throwable) {
LOG.error("Transaction failed:", throwable);
}
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> U readTransaction(
InstanceIdentifier<U> readIID, LogicalDatastoreType logicalDatastoreType) {
- ReadOnlyTransaction readTx = txChain.newReadOnlyTransaction();
- CheckedFuture<Optional<U>, ReadFailedException> readFuture = readTx.read(logicalDatastoreType, readIID);
- readTx.close();
+ final ListenableFuture<Optional<U>> readFuture;
+ try (ReadTransaction readTx = txChain.newReadOnlyTransaction()) {
+ readFuture = readTx.read(logicalDatastoreType, readIID);
+ }
try {
- Optional<U> optionalDataObject = readFuture.checkedGet();
+ Optional<U> optionalDataObject = readFuture.get();
if (optionalDataObject != null && optionalDataObject.isPresent()) {
return optionalDataObject.get();
} else {
LOG.debug("{}: Failed to read", Thread.currentThread().getStackTrace()[1]);
}
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to ....", e);
}
return null;
WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
writeTx.delete(logicalDatastoreType, deleteIID);
- Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() {
-
- public void onSuccess(Void result) {
+ writeTx.commit().addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(CommitInfo result) {
}
+ @Override
public void onFailure(Throwable throwable) {
LOG.error("Transaction failed:", throwable);
}
}, MoreExecutors.directExecutor());
}
- public void onTransactionChainFailed(TransactionChain<?, ?> chain, AsyncTransaction<?, ?> transaction,
- Throwable cause) {
+ @Override
+ public void onTransactionChainFailed(TransactionChain chain, Transaction transaction, Throwable cause) {
LOG.error("Broken chain {} in DataStoreBackEnd, transaction {}, cause {}", chain, transaction.getIdentifier(),
cause);
}
- public void onTransactionChainSuccessful(TransactionChain<?, ?> chain) {
+ @Override
+ public void onTransactionChainSuccessful(TransactionChain chain) {
LOG.info("DataStoreBackEnd closed successfully, chain {}", chain);
}
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
+import java.util.Optional;
import javax.xml.bind.DatatypeConverter;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.mapping.XtrIdMappingKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifierBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
@Captor private static ArgumentCaptor<InstanceIdentifier<AuthenticationKey>> iidCaptorAuthKey;
@Captor private static ArgumentCaptor<InstanceIdentifier<Mapping>> iidCaptorMapping;
@Captor private static ArgumentCaptor<InstanceIdentifier<XtrIdMapping>> iidCaptorXtrIdMapping;
- @Mock private static BindingTransactionChain txChainMock;
+ @Mock private static TransactionChain txChainMock;
@Mock private static WriteTransaction wTxMock;
private static DataStoreBackEnd dataStoreBackEnd;
PowerMockito.when(LoggerFactory.getLogger(DataStoreBackEnd.class))
.thenReturn(logMock);
Mockito.when(logMock.isDebugEnabled()).thenReturn(true);
- Mockito.when(brokerMock.createTransactionChain(Mockito.any(DataStoreBackEnd.class))).thenReturn(txChainMock);
+ Mockito.when(brokerMock.createMergingTransactionChain(Mockito.any(DataStoreBackEnd.class)))
+ .thenReturn(txChainMock);
dataStoreBackEnd = PowerMockito.spy(new DataStoreBackEnd(brokerMock));
Mockito.when(txChainMock.newWriteOnlyTransaction()).thenReturn(wTxMock);
- Mockito.when(wTxMock.submit())
- .thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
+ Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(wTxMock).commit();
}
/**
* Tests {@link DataStoreBackEnd#getAllMappings} method.
*/
@Test
- @SuppressWarnings("unchecked")
- public void getAllMappingsTest() throws ReadFailedException {
- final ReadOnlyTransaction rTxMock = Mockito.mock(ReadOnlyTransaction.class);
- final CheckedFuture<Optional<MappingDatabase>, ReadFailedException> readFutureMock
- = Mockito.mock(CheckedFuture.class);
- final Optional<MappingDatabase> optionalMock = Mockito.mock(Optional.class);
+ public void getAllMappingsTest() {
+ final ReadTransaction rTxMock = Mockito.mock(ReadTransaction.class);
+ final FluentFuture<Optional<MappingDatabase>> readFutureMock = FluentFutures.immediateFluentFuture(
+ Optional.of(getDefaultMappingDatabase().build()));
Mockito.when(txChainMock.newReadOnlyTransaction()).thenReturn(rTxMock);
Mockito.when(rTxMock.read(LogicalDatastoreType.CONFIGURATION, DATABASE_ROOT)).thenReturn(readFutureMock);
Mockito.when(rTxMock.read(LogicalDatastoreType.OPERATIONAL, DATABASE_ROOT)).thenReturn(readFutureMock);
- Mockito.when(readFutureMock.checkedGet()).thenReturn(optionalMock);
- Mockito.when(optionalMock.isPresent()).thenReturn(true);
- Mockito.when(optionalMock.get()).thenReturn(getDefaultMappingDatabase().build());
assertEquals(8, dataStoreBackEnd.getAllMappings().size());
- Mockito.verify(optionalMock, Mockito.times(2)).get();
}
/**
* Tests {@link DataStoreBackEnd#getAllAuthenticationKeys} method.
*/
@Test
- @SuppressWarnings("unchecked")
- public void getAllAuthenticationKeysTest() throws ReadFailedException {
- final ReadOnlyTransaction rTxMock = Mockito.mock(ReadOnlyTransaction.class);
- final CheckedFuture<Optional<MappingDatabase>, ReadFailedException> readFutureMock
- = Mockito.mock(CheckedFuture.class);
- final Optional<MappingDatabase> optionalMock = Mockito.mock(Optional.class);
+ public void getAllAuthenticationKeysTest() {
+ final ReadTransaction rTxMock = Mockito.mock(ReadTransaction.class);
+ final FluentFuture<Optional<MappingDatabase>> readFutureMock = FluentFutures.immediateFluentFuture(
+ Optional.of(getDefaultMappingDatabase().build()));
Mockito.when(txChainMock.newReadOnlyTransaction()).thenReturn(rTxMock);
Mockito.when(rTxMock.read(LogicalDatastoreType.CONFIGURATION, DATABASE_ROOT)).thenReturn(readFutureMock);
- Mockito.when(readFutureMock.checkedGet()).thenReturn(optionalMock);
- Mockito.when(optionalMock.isPresent()).thenReturn(true);
- Mockito.when(optionalMock.get()).thenReturn(getDefaultMappingDatabase().build());
assertEquals(4, dataStoreBackEnd.getAllAuthenticationKeys().size());
- Mockito.verify(optionalMock).get();
}
/**
*/
@Test
public void onTransactionChainFailedTest() {
- AsyncTransaction<?,?> asyncTransactionMock = Mockito.mock(AsyncTransaction.class);
+ Transaction asyncTransactionMock = Mockito.mock(Transaction.class);
Mockito.when(asyncTransactionMock.getIdentifier()).thenReturn(new Object());
dataStoreBackEnd.onTransactionChainFailed(Mockito.mock(TransactionChain.class), asyncTransactionMock,
Mockito.mock(Throwable.class));
import java.util.List;
import org.apache.commons.lang3.tuple.MutablePair;
import org.apache.commons.lang3.tuple.Pair;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.implementation.lisp.MapResolver;
import org.opendaylight.lispflowmapping.implementation.lisp.MapServer;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
private volatile boolean smr = ConfigIni.getInstance().smrIsSet();
private volatile String elpPolicy = ConfigIni.getInstance().getElpPolicy();
- private ThreadLocal<MapReply> tlsMapReply = new ThreadLocal<MapReply>();
- private ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotify =
- new ThreadLocal<Pair<MapNotify, List<TransportAddress>>>();
- private ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequest =
- new ThreadLocal<Pair<MapRequest, TransportAddress>>();
+ private ThreadLocal<MapReply> tlsMapReply = new ThreadLocal<>();
+ private ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotify = new ThreadLocal<>();
+ private ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequest = new ThreadLocal<>();
private final OdlLispSbService lispSB;
private IMapResolverAsync mapResolver;
return this.smr;
}
+ @Override
public void setShouldUseSmr(boolean shouldUseSmr) {
this.smr = shouldUseSmr;
if (mapServer != null) {
mapResolver.setSmrNotificationListener((ISmrNotificationListener) mapServer);
}
+ @Override
public MapReply handleMapRequest(MapRequest request) {
if (LOG.isDebugEnabled()) {
LOG.debug("LISP: Retrieving mapping for {}",
}
}
+ @Override
public Pair<MapNotify, List<TransportAddress>> handleMapRegister(MapRegister mapRegister) {
if (LOG.isDebugEnabled()) {
LOG.debug("LISP: Adding mapping for {}",
MapReply mapReply = handleMapRequest(mapRequestNotification.getMapRequest());
if (mapReply != null) {
SendMapReplyInputBuilder smrib = new SendMapReplyInputBuilder();
- smrib.setMapReply((new MapReplyBuilder(mapReply).build()));
+ smrib.setMapReply(new MapReplyBuilder(mapReply).build());
smrib.setTransportAddress(mapRequestNotification.getTransportAddress());
getLispSB().sendMapReply(smrib.build());
} else {
@Override
public void handleMapNotify(MapNotify notify, List<TransportAddress> rlocs) {
- tlsMapNotify.set(new MutablePair<MapNotify, List<TransportAddress>>(notify, rlocs));
+ tlsMapNotify.set(new MutablePair<>(notify, rlocs));
}
@Override
@Override
public void handleNonProxyMapRequest(MapRequest mapRequest, TransportAddress transportAddress) {
- tlsMapRequest.set(new MutablePair<MapRequest, TransportAddress>(mapRequest, transportAddress));
+ tlsMapRequest.set(new MutablePair<>(mapRequest, transportAddress));
}
private void destroy() {
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.mdsal.AuthenticationKeyDataListener;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
private final NotificationPublishService notificationPublishService;
private boolean mappingMergePolicy = ConfigIni.getInstance().mappingMergeIsSet();
- private boolean notificationPolicy = ConfigIni.getInstance().smrIsSet();
- private boolean iterateMask = true;
+ private final boolean notificationPolicy = ConfigIni.getInstance().smrIsSet();
+ private final boolean iterateMask = true;
private boolean isMaster = false;
public MappingService(final DataBroker broker,
}
if (LispAddressUtil.addressNeedsConversionFromBinary(originalRecord.getEid().getAddress())
- || (originalLocators != null && convertedLocators != null)) {
+ || originalLocators != null && convertedLocators != null) {
MappingRecordBuilder mrb = new MappingRecordBuilder(originalRecord);
mrb.setEid(LispAddressUtil.convertFromBinary(originalRecord.getEid()));
if (convertedLocators != null) {
LocatorRecordBuilder lrb = new LocatorRecordBuilder(record);
lrb.setRloc(LispAddressUtil.convertFromBinary(record.getRloc()));
if (convertedLocators == null) {
- convertedLocators = new ArrayList<LocatorRecord>();
+ convertedLocators = new ArrayList<>();
}
convertedLocators.add(lrb.build());
}
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.timebucket.implementation.TimeBucketMappingTimeoutService;
import org.opendaylight.lispflowmapping.mapcache.MultiTableMapCache;
import org.opendaylight.lispflowmapping.mapcache.SimpleMapCache;
import org.opendaylight.lispflowmapping.mapcache.lisp.LispMapCacheStringifier;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
private static final String AUTH_KEY_TABLE = "authentication";
//private static final int TTL_RLOC_TIMED_OUT = 1;
private static final int TTL_NO_RLOC_KNOWN = ConfigIni.getInstance().getNegativeMappingTTL();
- private NotificationPublishService notificationPublishService;
+ private final NotificationPublishService notificationPublishService;
private boolean mappingMerge;
- private ILispDAO dao;
+ private final ILispDAO dao;
private ILispDAO sdao;
private ILispMapCache smc;
private IMapCache pmc;
- private ConcurrentHashMap<Eid, Set<Subscriber>> subscriberdb = new ConcurrentHashMap<>();
+ private final ConcurrentHashMap<Eid, Set<Subscriber>> subscriberdb = new ConcurrentHashMap<>();
private IAuthKeyDb akdb;
private final EnumMap<MappingOrigin, IMapCache> tableMap = new EnumMap<>(MappingOrigin.class);
private DataStoreBackEnd dsbe;
private boolean isMaster = false;
- private ISouthBoundMappingTimeoutService sbMappingTimeoutService;
+ private final ISouthBoundMappingTimeoutService sbMappingTimeoutService;
public MappingSystem(ILispDAO dao, boolean iterateMask, NotificationPublishService nps, boolean mappingMerge) {
this.dao = dao;
}
private static MappingRecord getMappingRecord(MappingData mappingData) {
- return (mappingData != null) ? mappingData.getRecord() : null;
+ return mappingData != null ? mappingData.getRecord() : null;
}
@SuppressWarnings("unchecked")
* Since this method is only called when there is a hit in the southbound Map-Register cache, and that cache is
* not used when merge is on, it's OK to ignore the effects of timestamp changes on merging for now.
*/
+ @Override
public void refreshMappingRegistration(Eid key, XtrId xtrId, Long timestamp) {
sbMappingTimeoutService.removeExpiredMappings();
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.BooleanUtils;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.implementation.util.LoggingUtil;
import org.opendaylight.lispflowmapping.implementation.util.MSNotificationInputUtil;
import org.opendaylight.lispflowmapping.lisp.util.MappingRecordUtil;
import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey;
private static final Logger LOG = LoggerFactory.getLogger(MapServer.class);
private static final byte[] ALL_ZEROES_XTR_ID = new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0};
- private IMappingService mapService;
+ private final IMappingService mapService;
private boolean subscriptionService;
- private IMapNotifyHandler notifyHandler;
- private NotificationService notificationService;
+ private final IMapNotifyHandler notifyHandler;
+ private final NotificationService notificationService;
private ListenerRegistration<MapServer> mapServerListenerRegistration;
- private SmrScheduler scheduler;
+ private final SmrScheduler scheduler;
public MapServer(IMappingService mapService, boolean subscriptionService,
IMapNotifyHandler notifyHandler, NotificationService notificationService) {
this.subscriptionService = subscriptionService;
}
+ @Override
@SuppressWarnings("unchecked")
public void handleMapRegister(MapRegister mapRegister) {
boolean mappingUpdated = false;
MapNotifyBuilder builder = new MapNotifyBuilder();
List<TransportAddress> rlocs = null;
if (merge) {
- Set<IpAddressBinary> notifyRlocs = new LinkedHashSet<IpAddressBinary>();
- List<MappingRecordItem> mergedMappings = new ArrayList<MappingRecordItem>();
+ Set<IpAddressBinary> notifyRlocs = new LinkedHashSet<>();
+ List<MappingRecordItem> mergedMappings = new ArrayList<>();
for (MappingRecordItem record : mapRegister.getMappingRecordItem()) {
MappingRecord mapping = record.getMappingRecord();
MappingRecord currentRecord = getMappingRecord(mapService.getMapping(MappingOrigin.Southbound,
}
private static List<TransportAddress> getTransportAddresses(Set<IpAddressBinary> addresses) {
- List<TransportAddress> rlocs = new ArrayList<TransportAddress>();
+ List<TransportAddress> rlocs = new ArrayList<>();
for (IpAddressBinary address : addresses) {
TransportAddressBuilder tab = new TransportAddressBuilder();
tab.setIpAddress(address);
}
private static SiteId getSiteId(MapRegister mapRegister) {
- return (mapRegister.getSiteId() != null) ? new SiteId(mapRegister.getSiteId()) : null;
+ return mapRegister.getSiteId() != null ? new SiteId(mapRegister.getSiteId()) : null;
}
private static MappingRecord getMappingRecord(MappingData mappingData) {
- return (mappingData != null) ? mappingData.getRecord() : null;
+ return mappingData != null ? mappingData.getRecord() : null;
}
@Override
}
private final class CancellableRunnable implements Runnable {
- private MapRequestBuilder mrb;
- private Subscriber subscriber;
+ private final MapRequestBuilder mrb;
+ private final Subscriber subscriber;
private int executionCount = 1;
CancellableRunnable(MapRequestBuilder mrb, Subscriber subscriber) {
*/
package org.opendaylight.lispflowmapping.implementation.mdsal;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private ListenerRegistration<ClusteredDataTreeChangeListener<T>> operRegistration;
void registerDataChangeListener() {
- final DataTreeIdentifier<T> configDataTreeIdentifier = new DataTreeIdentifier<>(
+ final DataTreeIdentifier<T> configDataTreeIdentifier = DataTreeIdentifier.create(
LogicalDatastoreType.CONFIGURATION, path);
- final DataTreeIdentifier<T> operDataTreeIdentifier = new DataTreeIdentifier<>(
+ final DataTreeIdentifier<T> operDataTreeIdentifier = DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL, path);
configRegistration = broker.registerDataTreeChangeListener(configDataTreeIdentifier, this);
package org.opendaylight.lispflowmapping.implementation.mdsal;
import java.util.Collection;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
private static final Logger LOG = LoggerFactory.getLogger(MappingDataListener.class);
private IMappingSystem mapSystem;
private NotificationPublishService notificationPublishService;
- private boolean isMaster = false;
+ private final boolean isMaster = false;
public MappingDataListener(DataBroker broker, IMappingSystem msmr, NotificationPublishService nps) {
setBroker(broker);
}
if (LispAddressUtil.addressNeedsConversionToBinary(originalRecord.getEid().getAddress())
- || (originalLocators != null && convertedLocators != null)) {
+ || originalLocators != null && convertedLocators != null) {
MappingRecordBuilder mrb = new MappingRecordBuilder(originalRecord);
mrb.setEid(LispAddressUtil.convertToBinary(originalRecord.getEid()));
if (convertedLocators != null) {
LocatorRecordBuilder lrb = new LocatorRecordBuilder(record);
lrb.setRloc(LispAddressUtil.convertToBinary(record.getRloc()));
if (convertedLocators == null) {
- convertedLocators = new ArrayList<LocatorRecord>();
+ convertedLocators = new ArrayList<>();
}
convertedLocators.add(lrb.build());
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
- odl:type="pingpong" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService" />
<reference id="notificationService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationService" />
<reference id="lispDAO"
interface="org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO" />
<reference id="clusterSingletonService"
interface="org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler"
odl:type="default" />
<odl:notification-listener ref="lispMappingService" />
-</blueprint>
\ No newline at end of file
+</blueprint>
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
}
class TransportAddressMatch implements ArgumentMatcher<SendMapNotifyInput> {
+ @Override
public boolean matches(SendMapNotifyInput sendMapNotify) {
final TransportAddress notifyTransportAddress = sendMapNotify.getTransportAddress();
return TRANSPORT_ADDRESS_1.equals(notifyTransportAddress)
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.util.MappingMergeUtil;
import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
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.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
final MappingData mappingData = getDefaultMappingData(mappingRecord);
Mockito.when(pmcMock.getMapping(EID_IPV4_SRC, EID_SERVICE_PATH)).thenReturn(mappingData);
- final MappingData result = (MappingData) mappingSystem.getMapping(EID_IPV4_SRC, EID_SERVICE_PATH);
+ final MappingData result = mappingSystem.getMapping(EID_IPV4_SRC, EID_SERVICE_PATH);
final Ipv4Binary ipv4Result = (Ipv4Binary) result.getRecord().getLocatorRecord().get(0).getRloc().getAddress();
assertTrue(Arrays
.equals(InetAddress.getByName(IPV4_STRING_3).getAddress(), ipv4Result.getIpv4Binary().getValue()));
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.implementation.MappingService;
import org.opendaylight.lispflowmapping.implementation.MappingSystem;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
final RpcError error = rpc.getErrors().iterator().next();
//result
- final Future<RpcResult<GetMappingOutput>> result = (mappingService.getMapping(getMappingInput));
+ final Future<RpcResult<GetMappingOutput>> result = mappingService.getMapping(getMappingInput);
final RpcError errorResult = result.get().getErrors().iterator().next();
assertEquals(1, result.get().getErrors().size());
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
final InstanceIdentifier<AuthenticationKey> instanceIdentifierMock = Mockito.mock(InstanceIdentifier.class);
final DataTreeIdentifier<AuthenticationKey> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
change_del = Mockito.mock(DataTreeModification.class);
change_subtreeModified = Mockito.mock(DataTreeModification.class);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with DELETE modification type.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_delete() {
final List<DataTreeModification<AuthenticationKey>> changes = Lists.newArrayList(change_del);
Mockito.when(mod_del.getDataBefore()).thenReturn(AUTHENTICATION_KEY_1);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with WRITE modification type.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_write() {
final List<DataTreeModification<AuthenticationKey>> changes = Lists.newArrayList(change_write);
Mockito.when(mod_write.getDataAfter()).thenReturn(AUTHENTICATION_KEY_2);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with SUBTREE_MODIFIED modification type.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_subtreeModified() {
final List<DataTreeModification<AuthenticationKey>> changes = Lists.newArrayList(change_subtreeModified);
Mockito.when(mod_subtreeModified.getDataAfter()).thenReturn(AUTHENTICATION_KEY_3);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with multiple modification types.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_multipleModTypes() {
final List<DataTreeModification<AuthenticationKey>> changes =
Lists.newArrayList(change_del, change_write, change_subtreeModified);
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.implementation.util.MSNotificationInputUtil;
import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
import org.opendaylight.lispflowmapping.lisp.type.MappingData;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
final InstanceIdentifier<Mapping> instanceIdentifierMock = Mockito.mock(InstanceIdentifier.class);
final DataTreeIdentifier<Mapping> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
change_del = Mockito.mock(DataTreeModification.class);
change_subtreeModified = Mockito.mock(DataTreeModification.class);
* Tests {@link MappingDataListener#onDataTreeChanged} method with DELETE modification type from northbound.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_delete_NB() throws InterruptedException {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_del);
Mockito.when(mod_del.getDataBefore()).thenReturn(MAPPING_EID_1_NB);
* Tests {@link MappingDataListener#onDataTreeChanged} method with DELETE modification type from southbound.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_delete_SB() {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_del);
Mockito.when(mod_del.getDataBefore()).thenReturn(MAPPING_EID_1_SB);
*/
@Test
@Ignore
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_subtreeModified_NB() throws InterruptedException {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_subtreeModified);
final MappingChanged mapChanged = MSNotificationInputUtil.toMappingChanged(
* southbound.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_subtreeModified_SB() {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_subtreeModified);
Mockito.when(mod_subtreeModified.getDataAfter()).thenReturn(MAPPING_EID_2_SB);
*/
@Test
@Ignore
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_write_NB() throws InterruptedException {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_write);
final MappingChanged mapChanged = MSNotificationInputUtil.toMappingChanged(
* Tests {@link MappingDataListener#onDataTreeChanged} method with WRITE modification type from southbound.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_write_SB() {
final List<DataTreeModification<Mapping>> changes = Lists.newArrayList(change_write);
Mockito.when(mod_write.getDataAfter()).thenReturn(MAPPING_EID_3_SB);
*/
@Test
@Ignore
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_multipleChanges() throws InterruptedException {
final List<DataTreeModification<Mapping>> changes =
Lists.newArrayList(change_del, change_subtreeModified, change_write);
<type>pom</type>
<scope>import</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.10.0-SNAPSHOT</version>
- <type>pom</type>
- <scope>import</scope>
- </dependency>
</dependencies>
</dependencyManagement>
<artifactId>mappingservice.lisp-proto</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- <version>1.10.0-SNAPSHOT</version>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
import com.google.common.base.Preconditions;
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
*/
package org.opendaylight.lispflowmapping.neutron;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
import org.opendaylight.lispflowmapping.neutron.mappingmanager.HostInformationManager;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
*/
package org.opendaylight.lispflowmapping.neutron;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
public class NetworkListener extends DelegatingDataTreeListener<Network> {
private static final DataTreeIdentifier<Network> IDENTIFIER =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class));
public NetworkListener(DataProcessor<Network> dataProcessor, DataBroker dataBroker) {
*/
package org.opendaylight.lispflowmapping.neutron;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
public class PortListener extends DelegatingDataTreeListener<Port> {
private static final DataTreeIdentifier<Port> IDENTIFIER =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class));
public PortListener(DataProcessor<Port> dataProcessor, DataBroker dataBroker) {
*/
package org.opendaylight.lispflowmapping.neutron;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
public class SubnetListener extends DelegatingDataTreeListener<Subnet> {
private static final DataTreeIdentifier<Subnet> IDENTIFIER =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Neutron.class).child(Subnets.class).child(Subnet.class));
public SubnetListener(DataProcessor<Subnet> dataProcessor, DataBroker dataBroker) {
*/
package org.opendaylight.lispflowmapping.neutron.intenthandler;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
import org.opendaylight.lispflowmapping.neutron.intenthandler.listener.service.VbridgeTopologyListenerService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.opendaylight.lispflowmapping.neutron.intenthandler.listener;
import com.google.common.base.Preconditions;
-
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nonnull;
-
import org.checkerframework.checker.lock.qual.GuardedBy;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.network.topology.topology.topology.types.VbridgeTopology;
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.TopologyKey;
public class VbridgeTopologyListener implements ClusteredDataTreeChangeListener<VbridgeTopology>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(VbridgeTopologyListener.class);
- private DataBroker dataBroker;
- private MountPointService mountPointService;
+ private final DataBroker dataBroker;
+ private final MountPointService mountPointService;
@GuardedBy("this")
private final Map<TopologyKey, VppEndpointListener> domains = new ConcurrentHashMap<>();
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.neutron.intenthandler.IntentHandlerAsyncExecutorProvider;
import org.opendaylight.lispflowmapping.neutron.intenthandler.util.VppNetconfConnectionProbe;
import org.opendaylight.lispflowmapping.neutron.intenthandler.util.VppNodeReader;
import org.opendaylight.lispflowmapping.neutron.mappingmanager.HostInformationManager;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
hostInformationManager = HostInformationManager.getInstance();
reg = dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, topologyII), this);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, topologyII), this);
executorService = IntentHandlerAsyncExecutorProvider.getInstace().getExecutor();
}
package org.opendaylight.lispflowmapping.neutron.intenthandler.listener.service;
import javax.annotation.Nonnull;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.neutron.intenthandler.listener.VbridgeTopologyListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyTypesVbridgeAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.network.topology.topology.topology.types.VbridgeTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
private boolean closed;
private static final DataTreeIdentifier<VbridgeTopology> TREE_LISTENER_IDENTIFIER =
- new DataTreeIdentifier<>(
+ DataTreeIdentifier.create(
LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class)
*/
package org.opendaylight.lispflowmapping.neutron.intenthandler.util;
-import com.google.common.base.Optional;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPoint;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import java.util.Optional;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPoint;
+import org.opendaylight.mdsal.binding.api.MountPointService;
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.slf4j.Logger;
import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connecting;
import com.google.common.util.concurrent.SettableFuture;
-
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
-
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
public static final int NODE_CONNECTION_TIMER = 60;
private final DataBroker dataBroker;
private ListenerRegistration<VppNetconfConnectionProbe> registeredListener;
- private SettableFuture<Boolean> connectionStatusFuture = SettableFuture.create();
+ private final SettableFuture<Boolean> connectionStatusFuture = SettableFuture.create();
private static final String TOPOLOGY_IDENTIFIER = "topology-netconf";
.child(Node.class, new NodeKey(nodeId))
.build();
- path = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, nodeIid);
+ path = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, nodeIid);
}
public boolean startProbing() throws ExecutionException, InterruptedException, TimeoutException {
*/
package org.opendaylight.lispflowmapping.neutron.intenthandler.util;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
-
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
int retryCounter = RETRY_COUNT;
while (retryCounter > 0) {
- ReadOnlyTransaction readTransaction = dataBroker.newReadOnlyTransaction();
+ ReadTransaction readTransaction = dataBroker.newReadOnlyTransaction();
try {
returnData = readTransaction(instanceIdentifier, datastoreType, readTransaction);
LOG.trace("Netconf READ transaction SUCCESSFUL. Data present: {}", returnData.isPresent());
}
retryCounter--;
}
- return Optional.absent();
+ return Optional.empty();
}
private static <T extends DataObject> Optional<T> readTransaction(InstanceIdentifier<T> instanceIdentifier,
LogicalDatastoreType datastoreType,
- ReadOnlyTransaction readTransaction)
+ ReadTransaction readTransaction)
throws IllegalStateException, InterruptedException, ExecutionException {
-
- CheckedFuture<Optional<T>, ReadFailedException> futureData =
- readTransaction.read(datastoreType, instanceIdentifier);
-
- return futureData.get();
+ return readTransaction.read(datastoreType, instanceIdentifier).get();
}
}
*/
package org.opendaylight.lispflowmapping.neutron.intenthandler.util;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.MountPointService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.neutron.intenthandler.exception.RlocNotFoundOnVppNode;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
}
- resultFuture.set(Optional.absent());
+ resultFuture.set(Optional.empty());
} else {
LOG.debug("Data broker for vpp {} is missing.", instanceIdentifierToVppNode);
}
if (augIntf == null) {
LOG.debug("Cannot get Interface2 augmentation for intf {}");
- return Optional.absent();
+ return Optional.empty();
}
Ipv4 ipv4 = augIntf.getIpv4();
if (ipv4 == null) {
LOG.debug("Ipv4 address for interface {} on node {} is null!", augIntf, InfoUtil.node(iiToVpp));
- return Optional.absent();
+ return Optional.empty();
}
final List<Address> addresses = ipv4.getAddress();
if (addresses == null || addresses.isEmpty()) {
LOG.debug("Ipv4 addresses list is empty for interface {} on node {}", augIntf, InfoUtil.node(iiToVpp));
- return Optional.absent();
+ return Optional.empty();
}
final Ipv4AddressNoZone ip = addresses.iterator().next().getIp();
if (ip == null) {
LOG.debug("Ipv4AddressNoZone is null for node {}", InfoUtil.node(iiToVpp));
- return Optional.absent();
+ return Optional.empty();
}
LOG.debug("Got ip address {} from interface {} on node {}", ip.getValue(), intf.getName(),
<reference id="mappingService"
interface="org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping" />
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="mountPointService"
- interface="org.opendaylight.controller.md.sal.binding.api.MountPointService" />
+ interface="org.opendaylight.mdsal.binding.api.MountPointService" />
<odl:rpc-service id="odlMappingService" interface="org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService"/>
import com.google.common.collect.Lists;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
private static ILispNeutronService iLispNeutronServiceMock = Mockito.mock(ILispNeutronService.class);
private static DataBroker dataBrokerMock = Mockito.mock(DataBroker.class);
private static final DataTreeIdentifier<Network> NETWORK_ID =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
.child(Networks.class).child(Network.class));
private final DelegatingDataTreeListener<Network> networkDelegatingDataTreeListener =
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.lispflowmapping.interfaces.lisp.IFlowMapping;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.OdlMappingserviceService;
public class LispNeutronServiceTest {
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
import static org.junit.Assert.assertTrue;
-import java.util.concurrent.ExecutionException;
-
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
private static final IpPrefix IP_PREFIX = new IpPrefix(new Ipv4Prefix(IPV4 + MASK));
@Before
- @SuppressWarnings("unchecked")
public void init() {
odlMappingserviceServiceMock = Mockito.mock(OdlMappingserviceService.class);
}
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.Epoll;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.concurrent.ThreadFactory;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.inmemorydb.HashMapDb;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.southbound.lisp.LispXtrSouthboundHandler;
import org.opendaylight.lispflowmapping.southbound.lisp.cache.MapRegisterCache;
import org.opendaylight.lispflowmapping.type.sbplugin.IConfigLispSouthboundPlugin;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
private volatile boolean isMaster = false;
private volatile String bindingAddress;
private AuthKeyDb akdb;
- private MapRegisterCache mapRegisterCache = new MapRegisterCache();
+ private final MapRegisterCache mapRegisterCache = new MapRegisterCache();
private boolean mapRegisterCacheEnabled;
private long mapRegisterCacheTimeout;
private final ClusterSingletonServiceProvider clusterSingletonService;
private LispSouthboundHandler lispSouthboundHandler;
private LispXtrSouthboundHandler lispXtrSouthboundHandler;
- private NotificationPublishService notificationPublishService;
+ private final NotificationPublishService notificationPublishService;
private int numChannels = 1;
- private Channel[] channel;
+ private final Channel[] channel;
private Channel xtrChannel;
private Class channelType;
private volatile int xtrPort = LispMessage.XTR_PORT_NUM;
private volatile boolean listenOnXtrPort = false;
- private ConcurrentLispSouthboundStats statistics = new ConcurrentLispSouthboundStats();
- private Bootstrap bootstrap = new Bootstrap();
- private Bootstrap xtrBootstrap = new Bootstrap();
- private ThreadFactory threadFactory = new DefaultThreadFactory("lisp-sb");
+ private final ConcurrentLispSouthboundStats statistics = new ConcurrentLispSouthboundStats();
+ private final Bootstrap bootstrap = new Bootstrap();
+ private final Bootstrap xtrBootstrap = new Bootstrap();
+ private final ThreadFactory threadFactory = new DefaultThreadFactory("lisp-sb");
private EventLoopGroup eventLoopGroup;
- private DataBroker dataBroker;
+ private final DataBroker dataBroker;
private AuthenticationKeyDataListener authenticationKeyDataListener;
private DataStoreBackEnd dsbe;
if (LOG.isTraceEnabled()) {
LOG.trace("Buffer:\n{}", ByteBufUtil.prettyHexDump(data));
}
- senderChannel.write(packet).addListener(new ChannelFutureListener() {
- @Override
- public void operationComplete(ChannelFuture future) {
- if (future.isSuccess()) {
- LOG.trace("Success");
- statistics.incrementTx(packetType.getIntValue());
- } else {
- LOG.warn("Failed to send packet");
- statistics.incrementTxErrors();
- }
+ senderChannel.write(packet).addListener(future -> {
+ if (future.isSuccess()) {
+ LOG.trace("Success");
+ statistics.incrementTx(packetType.getIntValue());
+ } else {
+ LOG.warn("Failed to send packet");
+ statistics.incrementTxErrors();
}
});
senderChannel.flush();
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.mapcache.AuthKeyDb;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
private final AuthKeyDb akdb;
private final DataBroker broker;
private final InstanceIdentifier<AuthenticationKey> path;
- private ListenerRegistration<ClusteredDataTreeChangeListener<AuthenticationKey>> registration;
- private ConcurrentHashMap<Eid, Long> updatedEntries;
+ private
final ListenerRegistration<ClusteredDataTreeChangeListener<AuthenticationKey>> registration;
+ private final ConcurrentHashMap<Eid, Long> updatedEntries;
public AuthenticationKeyDataListener(final DataBroker broker, final AuthKeyDb akdb) {
this.broker = broker;
this.path = InstanceIdentifier.create(MappingDatabase.class).child(VirtualNetworkIdentifier.class)
.child(AuthenticationKey.class);
LOG.trace("Registering AuthenticationKey listener.");
- final DataTreeIdentifier<AuthenticationKey> dataTreeIdentifier = new DataTreeIdentifier<>(
+ final DataTreeIdentifier<AuthenticationKey> dataTreeIdentifier = DataTreeIdentifier.create(
LogicalDatastoreType.CONFIGURATION, path);
registration = broker.registerDataTreeChangeListener(dataTreeIdentifier, this);
this.updatedEntries = new ConcurrentHashMap<>();
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
- odl:type="pingpong" />
+ interface="org.opendaylight.mdsal.binding.api.DataBroker" />
<reference id="notificationPublishService"
- interface="org.opendaylight.controller.md.sal.binding.api.NotificationPublishService" />
+ interface="org.opendaylight.mdsal.binding.api.NotificationPublishService" />
<reference id="clusterSingletonService"
interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider" />
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.southbound.lisp.LispSouthboundHandler;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
* Tests {@link LispSouthboundPlugin#close} method.
*/
@Test
- @SuppressWarnings("unchecked")
public void closeTest() throws Exception {
EventLoopGroup elgMock = Mockito.mock(EventLoopGroup.class);
LispSouthboundPluginTest.injectField("eventLoopGroup", elgMock);
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.mapcache.AuthKeyDb;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
public void init() {
final InstanceIdentifier<AuthenticationKey> instanceIdentifierMock = Mockito.mock(InstanceIdentifier.class);
final DataTreeIdentifier<AuthenticationKey> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifierMock);
change_del = Mockito.mock(DataTreeModification.class);
change_subtreeModified = Mockito.mock(DataTreeModification.class);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with DELETE mod type, binary eid.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_delete_BinaryEid() {
Mockito.when(mod_del.getDataBefore()).thenReturn(AUTHENTICATION_KEY_1);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with DELETE mod type, Ipv4Prefix eid.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_delete_Ipv4PrefixEid() {
Mockito.when(mod_del.getDataBefore()).thenReturn(AUTHENTICATION_KEY_PREFIX);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with SUBTREE_MODIFIED mod type.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_subtreeModified() {
Mockito.when(mod_subtreeModified.getDataAfter()).thenReturn(AUTHENTICATION_KEY_2);
* Tests {@link AuthenticationKeyDataListener#onDataTreeChanged} method with WRITE mod type.
*/
@Test
- @SuppressWarnings("unchecked")
public void onDataTreeChangedTest_write() {
Mockito.when(mod_write.getDataAfter()).thenReturn(AUTHENTICATION_KEY_3);
import org.mockito.ArgumentMatchers;
import org.mockito.InOrder;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.lispflowmapping.lisp.serializer.MapNotifySerializer;
import org.opendaylight.lispflowmapping.lisp.serializer.MapReplySerializer;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.southbound.lisp.cache.MapRegisterCache;
import org.opendaylight.lispflowmapping.southbound.lisp.exception.LispMalformedPacketException;
import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana.afn.safi.rev130704.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
int LOCATOR = MapReplyIpv4SingleLocatorPos.LOCATOR + FIRST_LOCATOR_IPV4_LENGTH;
}
- @SuppressWarnings("unchecked")
@BeforeClass
public static void initTests() {
akdb = Mockito.mock(AuthKeyDb.class);
Code Review / lispflowmapping.git / commitdiff