<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
for plugin configuration etc. -->
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>config-artifacts</artifactId>
- <version>0.12.0</version>
- <type>pom</type>
- <scope>import</scope>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>mdsal-artifacts</artifactId>
- <version>1.11.0</version>
+ <artifactId>controller-artifacts</artifactId>
+ <version>2.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
- <version>1.11.0</version>
+ <version>2.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
- <version>1.11.0</version>
+ <version>2.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-mdsal-broker</artifactId>
- <version>1.11.0</version>
+ <version>2.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-lispflowmapping-southbound">
<feature name="odl-lispflowmapping-southbound">
- <feature version="[6,7)">odl-netty-4</feature>
- <feature version="[6,7)">odl-guava</feature>
+ <feature version="[7,8)">odl-netty-4</feature>
+ <feature version="[7,8)">odl-guava</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>1.11.0</version>
+ <version>2.0.1</version>
<relativePath/>
</parent>
sendMapRequest(mapRequest);
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().nonnullLocatorRecord().size());
MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
sendMapRegister(mapRegister);
MapNotify mapNotify = receiveMapNotify();
mapRequest.getEidItem().add(new EidItemBuilder().setEid(unMatchedAddress).build());
sendMapRequest(mapRequest.build());
mapReply = receiveMapReply();
- assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().nonnullLocatorRecord().size());
}
/*
// This registers an IP with a MapRegister, then adds a password via the
sendMapRequest(mapRequest);
MapReply mapReply = receiveMapReply();
assertEquals(4, mapReply.getNonce().longValue());
- assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().nonnullLocatorRecord().size());
MapRegister mapRegister = MappingServiceIntegrationTestUtil.getDefaultMapRegisterBuilder(eid).build();
sendMapRegister(mapRegister);
causeEntryToBeCleaned();
sendMapRequest(mapRequest);
mapReply = receiveMapReply();
- assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().size());
+ assertEquals(0, mapReply.getMappingRecordItem().get(0).getMappingRecord().nonnullLocatorRecord().size());
}
public void mapRequestMapRegisterAndMapRequestTestNativelyForwardTimeoutResponse() throws Exception {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<relativePath/>
</parent>
<artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>javax.xml.bind</groupId>
- <artifactId>jaxb-api</artifactId>
+ <groupId>jakarta.xml.bind</groupId>
+ <artifactId>jakarta.xml.bind-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
MappingDatabase mdb = readTransaction(DATABASE_ROOT, logicalDataStore);
if (mdb != null && mdb.getVirtualNetworkIdentifier() != null) {
- for (VirtualNetworkIdentifier id : mdb.getVirtualNetworkIdentifier()) {
- List<Mapping> ms = id.getMapping();
+ for (VirtualNetworkIdentifier id : mdb.nonnullVirtualNetworkIdentifier().values()) {
+ List<Mapping> ms = new ArrayList<>(id.nonnullMapping().values());
if (ms != null) {
mappings.addAll(ms);
}
MappingDatabase mdb = readTransaction(DATABASE_ROOT, LogicalDatastoreType.CONFIGURATION);
if (mdb != null && mdb.getVirtualNetworkIdentifier() != null) {
- for (VirtualNetworkIdentifier id : mdb.getVirtualNetworkIdentifier()) {
- List<AuthenticationKey> keys = id.getAuthenticationKey();
+ for (VirtualNetworkIdentifier id : mdb.nonnullVirtualNetworkIdentifier().values()) {
+ List<AuthenticationKey> keys = new ArrayList<>(id.nonnullAuthenticationKey().values());
if (keys != null) {
authKeys.addAll(keys);
}
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> void writePutTransaction(
InstanceIdentifier<U> addIID, U data, LogicalDatastoreType logicalDatastoreType, String errMsg) {
WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
- writeTx.put(logicalDatastoreType, addIID, data, true);
+ // TODO: is is a utility method, hence we do not have enough lifecycle knowledge to use plain put()
+ writeTx.mergeParentStructurePut(logicalDatastoreType, addIID, data);
writeTx.commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
import static org.junit.Assert.assertEquals;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.Map;
import java.util.Optional;
import javax.xml.bind.DatatypeConverter;
import org.junit.Before;
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.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifierKey;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
final AuthenticationKey authenticationKey = getDefaultAuthenticationKeyBuilder().build();
dataStoreBackEnd.addAuthenticationKey(authenticationKey);
- Mockito.verify(wTxMock).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION), iidCaptorAuthKey.capture(),
- Mockito.eq(authenticationKey), Mockito.eq(true));
+ Mockito.verify(wTxMock).mergeParentStructurePut(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ iidCaptorAuthKey.capture(), Mockito.eq(authenticationKey));
// result
AuthenticationKeyKey result = iidCaptorAuthKey.getValue().firstKeyOf(AuthenticationKey.class);
.setOrigin(MappingOrigin.Northbound).build();
dataStoreBackEnd.addMapping(mapping);
- Mockito.verify(wTxMock).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION), iidCaptorMapping.capture(),
- Mockito.eq(mapping), Mockito.eq(true));
+ Mockito.verify(wTxMock).mergeParentStructurePut(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ iidCaptorMapping.capture(), Mockito.eq(mapping));
// result
MappingKey result = iidCaptorMapping.getValue().firstKeyOf(Mapping.class);
.setMappingRecord(getDefaultMappingRecordBuilder().build()).build();
dataStoreBackEnd.addXtrIdMapping(xtrIdMapping);
- Mockito.verify(wTxMock).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), iidCaptorXtrIdMapping.capture(),
- Mockito.eq(xtrIdMapping), Mockito.eq(true));
+ Mockito.verify(wTxMock).mergeParentStructurePut(Mockito.eq(LogicalDatastoreType.OPERATIONAL),
+ iidCaptorXtrIdMapping.capture(), Mockito.eq(xtrIdMapping));
// result
XtrIdMappingKey xtrIdResult = iidCaptorXtrIdMapping.getValue().firstKeyOf(XtrIdMapping.class);
final AuthenticationKey authenticationKey = getDefaultAuthenticationKeyBuilder().build();
dataStoreBackEnd.updateAuthenticationKey(authenticationKey);
- Mockito.verify(wTxMock).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION), iidCaptorAuthKey.capture(),
- Mockito.eq(authenticationKey), Mockito.eq(true));
+ Mockito.verify(wTxMock).mergeParentStructurePut(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ iidCaptorAuthKey.capture(), Mockito.eq(authenticationKey));
// result
AuthenticationKeyKey result = iidCaptorAuthKey.getValue().firstKeyOf(AuthenticationKey.class);
.setOrigin(MappingOrigin.Northbound).build();
dataStoreBackEnd.updateMapping(mapping);
- Mockito.verify(wTxMock).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION), iidCaptorMapping.capture(),
- Mockito.eq(mapping), Mockito.eq(true));
+ Mockito.verify(wTxMock).mergeParentStructurePut(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ iidCaptorMapping.capture(), Mockito.eq(mapping));
// result
MappingKey result = iidCaptorMapping.getValue().firstKeyOf(Mapping.class);
return new AuthenticationKeyBuilder()
.withKey(new AuthenticationKeyKey(new EidUri(DUMMY_URI)))
.setEid(EID_IPV4_1)
- .setMappingAuthkey(new MappingAuthkeyBuilder().setKeyString("password").setKeyType(0).build());
+ .setMappingAuthkey(new MappingAuthkeyBuilder().setKeyString("password").setKeyType(Uint16.valueOf(0))
+ .build());
}
private static MappingDatabaseBuilder getDefaultMappingDatabase() {
final Mapping mapping_4 = new MappingBuilder()
.setMappingRecord(getDefaultMappingRecordBuilder().setEid(EID_IPV4_4).build()).build();
+ final Map<MappingKey, Mapping> mappingEntries_1 = new LinkedHashMap<>();
+ mappingEntries_1.put(new MappingKey(new EidUri("uri-1"), MappingOrigin.Northbound), mapping_1);
+ mappingEntries_1.put(new MappingKey(new EidUri("uri-2"), MappingOrigin.Northbound), mapping_2);
+ final Map<MappingKey, Mapping> mappingEntries_2 = new LinkedHashMap<>();
+ mappingEntries_2.put(new MappingKey(new EidUri("uri-3"), MappingOrigin.Northbound), mapping_3);
+ mappingEntries_2.put(new MappingKey(new EidUri("uri-4"), MappingOrigin.Northbound), mapping_4);
+
final AuthenticationKey authenticationKey_1 = new AuthenticationKeyBuilder()
.withKey(new AuthenticationKeyKey(new EidUri("uri-1"))).build();
final AuthenticationKey authenticationKey_2 = new AuthenticationKeyBuilder()
final AuthenticationKey authenticationKey_4 = new AuthenticationKeyBuilder()
.withKey(new AuthenticationKeyKey(new EidUri("uri-4"))).build();
+ final Map<AuthenticationKeyKey, AuthenticationKey> authKey_1 = new LinkedHashMap<>();
+ authKey_1.put(new AuthenticationKeyKey(new EidUri("uri-1")), authenticationKey_1);
+ authKey_1.put(new AuthenticationKeyKey(new EidUri("uri-2")), authenticationKey_2);
+ final Map<AuthenticationKeyKey, AuthenticationKey> authKey_2 = new LinkedHashMap<>();
+ authKey_2.put(new AuthenticationKeyKey(new EidUri("uri-3")), authenticationKey_3);
+ authKey_2.put(new AuthenticationKeyKey(new EidUri("uri-4")), authenticationKey_4);
+
final VirtualNetworkIdentifier vni_1 = new VirtualNetworkIdentifierBuilder()
.setVni(new VniUri("vni/uri/1"))
- .setMapping(Lists.newArrayList(mapping_1, mapping_2))
- .setAuthenticationKey(Lists.newArrayList(authenticationKey_1, authenticationKey_2)).build();
+ .setMapping(mappingEntries_1)
+ .setAuthenticationKey(authKey_1).build();
final VirtualNetworkIdentifier vni_2 = new VirtualNetworkIdentifierBuilder()
.setVni(new VniUri("vni/uri/2"))
- .setMapping(Lists.newArrayList(mapping_3, mapping_4))
- .setAuthenticationKey(Lists.newArrayList(authenticationKey_3, authenticationKey_4)).build();
- return new MappingDatabaseBuilder().setVirtualNetworkIdentifier(Lists.newArrayList(vni_1, vni_2));
+ .setMapping(mappingEntries_2)
+ .setAuthenticationKey(authKey_2).build();
+
+ final Map<VirtualNetworkIdentifierKey, VirtualNetworkIdentifier> vniEntries = new LinkedHashMap<>();
+ vniEntries.put(new VirtualNetworkIdentifierKey(new VniUri("vni/uri/1")), vni_1);
+ vniEntries.put(new VirtualNetworkIdentifierKey(new VniUri("vni/uri/2")), vni_2);
+
+ return new MappingDatabaseBuilder().setVirtualNetworkIdentifier(vniEntries);
}
}
@Override
public void onMappingKeepAlive(MappingKeepAlive notification) {
final MapRegisterCacheMetadata cacheMetadata = notification.getMapRegisterCacheMetadata();
- for (EidLispAddress eidLispAddress : cacheMetadata.getEidLispAddress()) {
+ for (EidLispAddress eidLispAddress : cacheMetadata.nonnullEidLispAddress().values()) {
final Eid eid = eidLispAddress.getEid();
final XtrId xtrId = cacheMetadata.getXtrId();
final Long timestamp = cacheMetadata.getTimestamp();
return null;
}
- List<LocatorRecord> sbLocators = sbMapping.getLocatorRecord();
+ List<LocatorRecord> sbLocators = sbMapping.nonnullLocatorRecord();
// We assume locators are unique and don't show up several times (with different or identical p/w/mp/mw),
// so we create a HashMap of the locators from the SB mapping record, keyed by the Rloc
// result
MappingData result = MappingMergeUtil.computeNbSbIntersection(nbMappingData, sbMappingData);
- assertEquals(0, result.getRecord().getLocatorRecord().size());
+ assertTrue(result.getRecord().nonnullLocatorRecord().isEmpty());
}
/**
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<relativePath/>
</parent>
public ByteBuffer serialize(MapReply mapReply) {
int size = Length.HEADER_SIZE;
- for (MappingRecordItem eidToLocatorRecord : mapReply.getMappingRecordItem()) {
+ for (MappingRecordItem eidToLocatorRecord : mapReply.nonnullMappingRecordItem()) {
size += MappingRecordSerializer.getInstance().getSerializationSize(eidToLocatorRecord.getMappingRecord());
}
}
replyBuffer.putLong(NumberUtil.asLong(mapReply.getNonce()));
if (mapReply.getMappingRecordItem() != null) {
- for (MappingRecordItem eidToLocatorRecord : mapReply.getMappingRecordItem()) {
+ for (MappingRecordItem eidToLocatorRecord : mapReply.nonnullMappingRecordItem()) {
MappingRecordSerializer.getInstance().serialize(replyBuffer, eidToLocatorRecord.getMappingRecord());
}
}
grouping eid-list {
list eid-item {
key "eid-item-id";
+ ordered-by user;
leaf eid-item-id {
type string;
}
grouping LocatorRecords {
list LocatorRecord {
key "locator-id";
+ ordered-by user;
leaf locator-id {
type string;
}
grouping mapping-record-list {
list mapping-record-item {
key "mapping-record-item-id";
+ ordered-by user;
leaf mapping-record-item-id {
type string;
}
}
list itrRloc {
key "itr-rloc-id";
+ ordered-by user;
leaf itr-rloc-id {
type string;
}
.withKey(new HopKey("hop_2"))
.setLrsBits(new Hop.LrsBits(true, true, true)).build();
private static final List<Hop> HOP_LIST = new ArrayList<>();
- private static final ExplicitLocatorPath EXPLICIT_LOCATOR_PATH = new ExplicitLocatorPathBuilder()
- .setExplicitLocatorPath(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types
- .rev151105.lisp.address.address.explicit.locator.path.ExplicitLocatorPathBuilder().setHop(HOP_LIST)
- .build()).build();
- private static final LispAddress LISP_EXPLICIT_LOCATOR_PATH = new EidBuilder().setAddress(EXPLICIT_LOCATOR_PATH)
- .build();
// SourceDestKey
private static final SourceDestKey SOURCE_DEST_KEY = new SourceDestKeyBuilder().setSourceDestKey(new org
HOP_LIST.add(HOP_1);
HOP_LIST.add(HOP_2);
- assertEquals(getStringFromExplicLocPath(), LispAddressStringifier.getString(LISP_EXPLICIT_LOCATOR_PATH));
+ ExplicitLocatorPath elp = new ExplicitLocatorPathBuilder().setExplicitLocatorPath(
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
+ .address.address.explicit.locator.path.ExplicitLocatorPathBuilder().setHop(HOP_LIST)
+ .build()).build();
+ LispAddress lelp = new EidBuilder().setAddress(elp).build();
+ assertEquals(getStringFromExplicLocPath(), LispAddressStringifier.getString(lelp));
}
private static String getStringFromSrcDstKey() {
ExplicitLocatorPath elp = (ExplicitLocatorPath) address.getAddress();
List<Hop> hops = elp.getExplicitLocatorPath().getHop();
- assertEquals(0, hops.size());
+ assertNull(hops);
}
@Test(expected = LispSerializationException.class)
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
</dependency>
<!--Needed for testing-->
*/
package org.opendaylight.lispflowmapping.neutron;
-import java.util.List;
+import java.util.Map;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.neutron.mappingmanager.HostInformationManager;
import org.opendaylight.lispflowmapping.neutron.mappingmanager.PortData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- List<FixedIps> fixedIPs = port.getFixedIps();
+ Map<FixedIpsKey, FixedIps> fixedIPs = port.nonnullFixedIps();
if (fixedIPs != null && fixedIPs.size() > 0) {
Eid eidAddress;
- for (FixedIps ip : fixedIPs) {
+ for (FixedIps ip : fixedIPs.values()) {
// TODO Add check/support for IPv6.
// Get subnet for this port, based on v4 or v6 decide address
LOG.info("Neutron Port Created: Port name: "
+ port.getName()
+ " Port Fixed IP: "
- + (port.getFixedIps() != null ? port.getFixedIps().get(0)
+ + (port.getFixedIps() != null ? port.getFixedIps().values().iterator().next()
: "No Fixed IP assigned"));
}
return;
}
- List<FixedIps> fixedIPs = port.getFixedIps();
+ Map<FixedIpsKey, FixedIps> fixedIPs = port.getFixedIps();
if (fixedIPs != null && fixedIPs.size() > 0) {
Eid eidAddress;
- for (FixedIps ip : fixedIPs) {
+ for (FixedIps ip : fixedIPs.values()) {
eidAddress = getEid(port, ip);
LOG.info("Neutron Port updated: Port name: "
+ port.getName()
+ " Port Fixed IP: "
- + (port.getFixedIps() != null ? port.getFixedIps().get(0)
+ + (port.getFixedIps() != null ? port.getFixedIps().values().iterator().next()
: "No Fixed IP assigned"));
LOG.debug("Neutron Port Updated : " + port.toString());
}
LOG.info("Neutron Port Deleted: Port name: "
+ port.getName()
+ " Port Fixed IP: "
- + (port.getFixedIps() != null ? port.getFixedIps().get(0)
+ + (port.getFixedIps() != null ? port.getFixedIps().values().iterator().next()
: "No Fixed IP assigned"));
LOG.debug("Neutron Port Deleted : " + port.toString());
- List<FixedIps> fixedIPs = port.getFixedIps();
+ Map<FixedIpsKey, FixedIps> fixedIPs = port.getFixedIps();
if (fixedIPs != null && fixedIPs.size() > 0) {
Eid eidAddress;
- for (FixedIps ip : fixedIPs) {
+ for (FixedIps ip : fixedIPs.values()) {
// TODO Add check/support for IPv6.
// Get subnet for this port, based on v4 or v6 decide address
}
private void processNodeOnConnection(final Node newOrModifiedNode) {
- for (SupportingNode supportingNode : newOrModifiedNode.getSupportingNode()) {
+ for (SupportingNode supportingNode : newOrModifiedNode.nonnullSupportingNode().values()) {
final NodeId nodeMount = supportingNode.getNodeRef();
final VppNetconfConnectionProbe probe = new VppNetconfConnectionProbe(supportingNode.getNodeRef(),
dataBroker);
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.lispflowmapping.neutron.intenthandler.exception.RlocNotFoundOnVppNode;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.AddressKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.Loopback;
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;
LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(InterfacesState.class));
if (interfacesOnVppNodeOptional.isPresent()) {
- for (Interface intf : interfacesOnVppNodeOptional.get().getInterface()) {
+ for (Interface intf : interfacesOnVppNodeOptional.get().nonnullInterface().values()) {
if (intf.getType().equals(Loopback.class)) {
continue;
return Optional.empty();
}
- final List<Address> addresses = ipv4.getAddress();
+ final Map<AddressKey, 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.empty();
}
- final Ipv4AddressNoZone ip = addresses.iterator().next().getIp();
+ final Ipv4AddressNoZone ip = addresses.values().iterator().next().getIp();
if (ip == null) {
LOG.debug("Ipv4AddressNoZone is null for node {}", InfoUtil.node(iiToVpp));
return Optional.empty();
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.util.List;
+import java.util.LinkedHashMap;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.junit.Before;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIpsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yangtools.yang.common.RpcResult;
private static final String IPV4 = "192.168.0.1";
private static final Address ADDRESS = new DistinguishedNameBuilder()
.setDistinguishedName(new DistinguishedNameType(HOST_ID_1)).build();
+ private static final String UUID_STRING = "123e4567-e89b-12d3-a456-426655440000";
private PortDataProcessor portDataProcessor = new PortDataProcessor(iLispNeutronServiceMock);
IllegalAccessException, InvocationTargetException {
portDataProcessor.create(portMock);
- List<FixedIps> fixedIps = portMock.getFixedIps();
+ Map<FixedIpsKey, FixedIps> fixedIps = portMock.nonnullFixedIps();
- for (FixedIps ip : fixedIps) {
+ for (FixedIps ip : fixedIps.values()) {
Mockito.verify(hostInformationManager).addHostRelatedInfo(HOST_ID_1,
getEid(portDataProcessor, portMock, ip));
}
portDataProcessor.create(portMock);
- List<FixedIps> fixedIps = portMock.getFixedIps();
+ Map<FixedIpsKey, FixedIps> fixedIps = portMock.getFixedIps();
Mockito.verifyZeroInteractions(hostInformationManager);
}
return new MappingRecordBuilder().setLocatorRecord(Lists.newArrayList(getDefaultLocatorRecord())).build();
}
- private static List<FixedIps> getDefaultListOfFixedIps() {
- FixedIps fixedIps = new FixedIpsBuilder().setIpAddress(new IpAddress(new Ipv4Address(IPV4))).build();
+ private static Map<FixedIpsKey, FixedIps> getDefaultListOfFixedIps() {
+ IpAddress ipv4 = new IpAddress(new Ipv4Address(IPV4));
+ FixedIps fixedIps = new FixedIpsBuilder().setIpAddress(ipv4).build();
- return Lists.newArrayList(fixedIps);
+ return new LinkedHashMap<>(Map.of(new FixedIpsKey(ipv4, new Uuid(UUID_STRING)), fixedIps));
}
private static Eid getEid(PortDataProcessor portDataProcessor, Port port, FixedIps ip)
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>6.0.4</version>
+ <version>7.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>5.0.9</version>
+ <version>6.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
package org.opendaylight.lispflowmapping.southbound.lisp;
import java.util.Collection;
-import java.util.List;
+import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
import org.opendaylight.lispflowmapping.mapcache.AuthKeyDb;
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.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressKey;
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 org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKeyBuilder;
* @param timeout MapRegister cache timeout value
* @return false if any of the EIDs in the eids list was updated in the last timout period, true otherwise
*/
- public synchronized boolean authKeysForEidsUnchanged(List<EidLispAddress> eids, long timeout) {
+ public synchronized boolean authKeysForEidsUnchanged(Map<EidLispAddressKey, EidLispAddress> eids, long timeout) {
boolean result = true;
Long currentTime = System.currentTimeMillis();
- for (EidLispAddress eidLispAddress : eids) {
+ for (EidLispAddress eidLispAddress : eids.values()) {
Long updateTime = updatedEntries.get(eidLispAddress.getEid());
if (updateTime != null) {
result = false;
import io.netty.channel.socket.DatagramPacket;
import java.net.InetAddress;
import java.nio.ByteBuffer;
-import java.util.ArrayList;
import java.util.Arrays;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadataBuilder;
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.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.value.grouping.MapRegisterCacheValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.value.grouping.MapRegisterCacheValueBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
}
private MapRegisterCacheValue refreshAuthKeyIfNecessary(MapRegisterCacheValue mapRegisterCacheValue) {
- final List<EidLispAddress> eids = mapRegisterCacheValue.getMapRegisterCacheMetadata().getEidLispAddress();
+ final Map<EidLispAddressKey, EidLispAddress> eids = mapRegisterCacheValue.getMapRegisterCacheMetadata()
+ .getEidLispAddress();
if (lispSbPlugin.getAuthenticationKeyDataListener().authKeysForEidsUnchanged(
eids, lispSbPlugin.getMapRegisterCacheTimeout())) {
/**
* Returns null if not all of eids have the same value of authentication key.
*/
- private MappingAuthkey provideAuthenticateKey(final List<EidLispAddress> eidLispAddresses) {
+ private MappingAuthkey provideAuthenticateKey(final Map<EidLispAddressKey, EidLispAddress> eidLispAddresses) {
MappingAuthkey firstAuthKey = null;
+ if (eidLispAddresses == null) {
+ return null;
+ }
for (int i = 0; i < eidLispAddresses.size(); i++) {
- final Eid eid = eidLispAddresses.get(i).getEid();
+ final Eid eid = eidLispAddresses.get(new EidLispAddressKey(Integer.toString(i))).getEid();
if (i == 0) {
firstAuthKey = lispSbPlugin.getAkdb().getAuthenticationKey(eid);
} else {
return buffer;
}
- private List<EidLispAddress> provideEidPrefixesFromMessage(final MapRegister mapRegister) {
- List<EidLispAddress> eidsResult = new ArrayList<>();
+ private Map<EidLispAddressKey, EidLispAddress> provideEidPrefixesFromMessage(final MapRegister mapRegister) {
+ Map<EidLispAddressKey, EidLispAddress> eidsResult = new LinkedHashMap<>();
+ int idx = 0;
for (MappingRecordItem mappingRecordItem : mapRegister.getMappingRecordItem()) {
final EidLispAddressBuilder eidLispAddressBuilder = new EidLispAddressBuilder();
final Eid eid = mappingRecordItem.getMappingRecord().getEid();
eidLispAddressBuilder.setEidLispAddressId(LispAddressStringifier.getString(eid));
eidLispAddressBuilder.setEid(eid);
- eidsResult.add(eidLispAddressBuilder.build());
+ eidsResult.put(new EidLispAddressKey(Integer.toString(idx)), eidLispAddressBuilder.build());
}
return eidsResult;
}
.thenReturn(new MappingAuthkeyBuilder().setKeyType(1).setKeyString("password").build());
akdl = Mockito.mock(AuthenticationKeyDataListener.class);
- Mockito.when(akdl.authKeysForEidsUnchanged(Mockito.anyList(), Mockito.anyLong())).thenReturn(true);
+ Mockito.when(akdl.authKeysForEidsUnchanged(Mockito.anyMap(), Mockito.anyLong())).thenReturn(true);
}
@Override
Code Review / lispflowmapping.git / commitdiff